dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11 #ifndef SWIGCSHARP
  12 #define SWIGCSHARP
  13 #endif
  14
  15 #define SWIG_DIRECTORS
  16
  17 #ifdef __cplusplus
  18 /* SwigValueWrapper is described in swig.swg */
  19 template<typename T> class SwigValueWrapper {
  20   struct SwigMovePointer {
  21     T *ptr;
  22     SwigMovePointer(T *p) : ptr(p) { }
  23     ~SwigMovePointer() { delete ptr; }
  24     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  25   } pointer;
  26   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  27   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  28 public:
  29   SwigValueWrapper() : pointer(0) { }
  30   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  31   operator T&() const { return *pointer.ptr; }
  32   T *operator&() { return pointer.ptr; }
  33 };
  34
  35 template <typename T> T SwigValueInit() {
  36   return T();
  37 }
  38 #endif
  39
  40 /* -----------------------------------------------------------------------------
  41  *  This section contains generic SWIG labels for method/variable
  42  *  declarations/attributes, and other compiler dependent labels.
  43  * ----------------------------------------------------------------------------- */
  44
  45 /* template workaround for compilers that cannot correctly implement the C++ standard */
  46 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  47 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  48 #  define SWIGTEMPLATEDISAMBIGUATOR template
  49 # elif defined(__HP_aCC)
  50 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  51 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  52 #  define SWIGTEMPLATEDISAMBIGUATOR template
  53 # else
  54 #  define SWIGTEMPLATEDISAMBIGUATOR
  55 # endif
  56 #endif
  57
  58 /* inline attribute */
  59 #ifndef SWIGINLINE
  60 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  61 #   define SWIGINLINE inline
  62 # else
  63 #   define SWIGINLINE
  64 # endif
  65 #endif
  66
  67 /* attribute recognised by some compilers to avoid 'unused' warnings */
  68 #ifndef SWIGUNUSED
  69 # if defined(__GNUC__)
  70 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  71 #     define SWIGUNUSED __attribute__ ((__unused__))
  72 #   else
  73 #     define SWIGUNUSED
  74 #   endif
  75 # elif defined(__ICC)
  76 #   define SWIGUNUSED __attribute__ ((__unused__))
  77 # else
  78 #   define SWIGUNUSED
  79 # endif
  80 #endif
  81
  82 #ifndef SWIG_MSC_UNSUPPRESS_4505
  83 # if defined(_MSC_VER)
  84 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  85 # endif
  86 #endif
  87
  88 #ifndef SWIGUNUSEDPARM
  89 # ifdef __cplusplus
  90 #   define SWIGUNUSEDPARM(p)
  91 # else
  92 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  93 # endif
  94 #endif
  95
  96 /* internal SWIG method */
  97 #ifndef SWIGINTERN
  98 # define SWIGINTERN static SWIGUNUSED
  99 #endif
 100
 101 /* internal inline SWIG method */
 102 #ifndef SWIGINTERNINLINE
 103 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 104 #endif
 105
 106 /* exporting methods */
 107 #if defined(__GNUC__)
 108 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 109 #    ifndef GCC_HASCLASSVISIBILITY
 110 #      define GCC_HASCLASSVISIBILITY
 111 #    endif
 112 #  endif
 113 #endif
 114
 115 #ifndef SWIGEXPORT
 116 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 117 #   if defined(STATIC_LINKED)
 118 #     define SWIGEXPORT
 119 #   else
 120 #     define SWIGEXPORT __declspec(dllexport)
 121 #   endif
 122 # else
 123 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 124 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 125 #   else
 126 #     define SWIGEXPORT
 127 #   endif
 128 # endif
 129 #endif
 130
 131 /* calling conventions for Windows */
 132 #ifndef SWIGSTDCALL
 133 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 134 #   define SWIGSTDCALL __stdcall
 135 # else
 136 #   define SWIGSTDCALL
 137 # endif
 138 #endif
 139
 140 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 141 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 142 # define _CRT_SECURE_NO_DEPRECATE
 143 #endif
 144
 145 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 146 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 147 # define _SCL_SECURE_NO_DEPRECATE
 148 #endif
 149
 150 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 151 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 152 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 153 #endif
 154
 155 /* Intel's compiler complains if a variable which was never initialised is
 156  * cast to void, which is a common idiom which we use to indicate that we
 157  * are aware a variable isn't used.  So we just silence that warning.
 158  * See: https://github.com/swig/swig/issues/192 for more discussion.
 159  */
 160 #ifdef __INTEL_COMPILER
 161 # pragma warning disable 592
 162 #endif
 163
 164
 165 #include <stdlib.h>
 166 #include <string.h>
 167 #include <stdio.h>
 168
 169 /* Support for throwing C# exceptions from C/C++. There are two types:
 170  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 171 typedef enum {
 172   SWIG_CSharpApplicationException,
 173   SWIG_CSharpArithmeticException,
 174   SWIG_CSharpDivideByZeroException,
 175   SWIG_CSharpIndexOutOfRangeException,
 176   SWIG_CSharpInvalidCastException,
 177   SWIG_CSharpInvalidOperationException,
 178   SWIG_CSharpIOException,
 179   SWIG_CSharpNullReferenceException,
 180   SWIG_CSharpOutOfMemoryException,
 181   SWIG_CSharpOverflowException,
 182   SWIG_CSharpSystemException
 183 } SWIG_CSharpExceptionCodes;
 184
 185 typedef enum {
 186   SWIG_CSharpArgumentException,
 187   SWIG_CSharpArgumentNullException,
 188   SWIG_CSharpArgumentOutOfRangeException
 189 } SWIG_CSharpExceptionArgumentCodes;
 190
 191 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 192 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 193
 194 typedef struct {
 195   SWIG_CSharpExceptionCodes code;
 196   SWIG_CSharpExceptionCallback_t callback;
 197 } SWIG_CSharpException_t;
 198
 199 typedef struct {
 200   SWIG_CSharpExceptionArgumentCodes code;
 201   SWIG_CSharpExceptionArgumentCallback_t callback;
 202 } SWIG_CSharpExceptionArgument_t;
 203
 204 SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 205   { SWIG_CSharpApplicationException, NULL },
 206   { SWIG_CSharpArithmeticException, NULL },
 207   { SWIG_CSharpDivideByZeroException, NULL },
 208   { SWIG_CSharpIndexOutOfRangeException, NULL },
 209   { SWIG_CSharpInvalidCastException, NULL },
 210   { SWIG_CSharpInvalidOperationException, NULL },
 211   { SWIG_CSharpIOException, NULL },
 212   { SWIG_CSharpNullReferenceException, NULL },
 213   { SWIG_CSharpOutOfMemoryException, NULL },
 214   { SWIG_CSharpOverflowException, NULL },
 215   { SWIG_CSharpSystemException, NULL }
 216 };
 217
 218 SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 219   { SWIG_CSharpArgumentException, NULL },
 220   { SWIG_CSharpArgumentNullException, NULL },
 221   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 222 };
 223
 224 void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 225   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 226   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 227     callback = SWIG_csharp_exceptions[code].callback;
 228   }
 229   callback(msg);
 230 }
 231
 232 void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 233   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 234   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 235     callback = SWIG_csharp_exceptions_argument[code].callback;
 236   }
 237   callback(msg, param_name);
 238 }
 239
 240
 241 #ifdef __cplusplus
 242 extern "C"
 243 #endif
 244 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 245                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 246                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 247                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 248                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 249                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 250                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 251                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 252                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 253                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 254                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 255                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 256   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 257   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 258   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 259   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 267 }
 268
 269 #ifdef __cplusplus
 270 extern "C"
 271 #endif
 272 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 273                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 274                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 275                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 276   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 277   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 278   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 279 }
 280
 281
 282 /* Callback for returning strings to C# without leaking memory */
 283 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 284 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 285
 286 // keep argWidgetCs and argWidgetV so they're always available to DALi
 287 int argWidgetC = 1;
 288 char **argWidgetV = NULL;
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318
 319 /* -----------------------------------------------------------------------------
 320  * director_common.swg
 321  *
 322  * This file contains support for director classes which is common between
 323  * languages.
 324  * ----------------------------------------------------------------------------- */
 325
 326 /*
 327   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 328   'Swig' namespace. This could be useful for multi-modules projects.
 329 */
 330 #ifdef SWIG_DIRECTOR_STATIC
 331 /* Force anonymous (static) namespace */
 332 #define Swig
 333 #endif
 334 /* -----------------------------------------------------------------------------
 335  * director.swg
 336  *
 337  * This file contains support for director classes so that C# proxy
 338  * methods can be called from C++.
 339  * ----------------------------------------------------------------------------- */
 340
 341 #if defined(DEBUG_DIRECTOR_OWNED)
 342 #include <iostream>
 343 #endif
 344 #include <string>
 345 #include <exception>
 346
 347 namespace Swig {
 348   /* Director base class - not currently used in C# directors */
 349   class Director {
 350   };
 351
 352   /* Base class for director exceptions */
 353   class DirectorException : public std::exception {
 354   protected:
 355     std::string swig_msg;
 356
 357   public:
 358     DirectorException(const char *msg) : swig_msg(msg) {
 359     }
 360
 361     DirectorException(const std::string &msg) : swig_msg(msg) {
 362     }
 363
 364     virtual ~DirectorException() throw() {
 365     }
 366
 367     const char *what() const throw() {
 368       return swig_msg.c_str();
 369     }
 370   };
 371
 372   /* Pure virtual method exception */
 373   class DirectorPureVirtualException : public DirectorException {
 374   public:
 375     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 376     }
 377   };
 378 }
 379
 380
 381 void SWIG_CSharpException(int code, const char *msg) {
 382   if (code == SWIG_ValueError) {
 383     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 384     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 385   } else {
 386     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 387     switch(code) {
 388     case SWIG_MemoryError:
 389       exception_code = SWIG_CSharpOutOfMemoryException;
 390       break;
 391     case SWIG_IndexError:
 392       exception_code = SWIG_CSharpIndexOutOfRangeException;
 393       break;
 394     case SWIG_DivisionByZero:
 395       exception_code = SWIG_CSharpDivideByZeroException;
 396       break;
 397     case SWIG_IOError:
 398       exception_code = SWIG_CSharpIOException;
 399       break;
 400     case SWIG_OverflowError:
 401       exception_code = SWIG_CSharpOverflowException;
 402       break;
 403     case SWIG_RuntimeError:
 404     case SWIG_TypeError:
 405     case SWIG_SyntaxError:
 406     case SWIG_SystemError:
 407     case SWIG_UnknownError:
 408     default:
 409       exception_code = SWIG_CSharpApplicationException;
 410       break;
 411     }
 412     SWIG_CSharpSetPendingException(exception_code, msg);
 413   }
 414 }
 415
 416
 417 #include <stdexcept>
 418
 419
 420 #define SWIGSTDCALL
 421
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425
 426 #include <dali/devel-api/actors/actor-devel.h>
 427 #include <dali/devel-api/common/stage-devel.h>
 428 #include <dali/devel-api/events/key-event-devel.h>
 429
 430 #include <dali/public-api/math/matrix.h>
 431 #include <dali/public-api/math/matrix3.h>
 432 #include <dali/public-api/math/viewport.h>
 433 #include <dali/public-api/object/property-key.h>
 434 #include <dali/devel-api/object/csharp-type-info.h>
 435 #include <dali/devel-api/object/csharp-type-registry.h>
 436
 437 #include <dali/public-api/adaptor-framework/timer.h>
 438 #include <dali/public-api/adaptor-framework/style-change.h>
 439 #include <dali/devel-api/adaptor-framework/environment-variable.h>
 440
 441 #include <dali/devel-api/images/nine-patch-image.h>
 442
 443 #include <dali-toolkit/devel-api/builder/builder.h>
 444
 445 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 446 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 447
 448 #include <dali-toolkit/devel-api/controls/control-devel.h>
 449 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 450 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 451 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 455 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 456
 457 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 458 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 459 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 460
 461 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 462 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 463 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 464
 465 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 466 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 467 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
 468
 469 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 470
 471 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 472 #include <dali/devel-api/adaptor-framework/image-loading.h>
 473
 474 #include <dali/public-api/events/mouse-button.h>
 475
 476 #include <dali-toolkit/devel-api/controls/web-view/web-view.h>
 477 #include "web-view-signal-converter.h"
 478
 479 #include <dali/integration-api/debug.h>
 480
 481 // add here SWIG version check
 482
 483 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 484 // disable Swig-dependent warnings
 485
 486 // 'identifier1' has C-linkage specified,
 487 // but returns UDT 'identifier2' which is incompatible with C
 488 #pragma warning(disable: 4190)
 489
 490 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 491 #pragma warning(disable: 4800)
 492
 493 // debug info too long etc etc
 494 #pragma warning(disable: 4786)
 495 #endif
 496
 497
 498 #include <stdexcept>
 499
 500
 501 #include <string>
 502
 503
 504 #include <vector>
 505 #include <algorithm>
 506 #include <stdexcept>
 507
 508
 509 #include <map>
 510 #include <algorithm>
 511 #include <stdexcept>
 512
 513
 514 #include <utility>
 515
 516
 517 typedef float floatp;
 518
 519 SWIGINTERN floatp *new_floatp(){
 520   return new float();
 521 }
 522 SWIGINTERN void delete_floatp(floatp *self){
 523   if (self) delete self;
 524 }
 525 SWIGINTERN void floatp_assign(floatp *self,float value){
 526   *self = value;
 527 }
 528 SWIGINTERN float floatp_value(floatp *self){
 529   return *self;
 530 }
 531 SWIGINTERN float *floatp_cast(floatp *self){
 532   return self;
 533 }
 534 SWIGINTERN floatp *floatp_frompointer(float *t){
 535   return (floatp *) t;
 536 }
 537
 538 typedef int intp;
 539
 540 SWIGINTERN intp *new_intp(){
 541   return new int();
 542 }
 543 SWIGINTERN void delete_intp(intp *self){
 544   if (self) delete self;
 545 }
 546 SWIGINTERN void intp_assign(intp *self,int value){
 547   *self = value;
 548 }
 549 SWIGINTERN int intp_value(intp *self){
 550   return *self;
 551 }
 552 SWIGINTERN int *intp_cast(intp *self){
 553   return self;
 554 }
 555 SWIGINTERN intp *intp_frompointer(int *t){
 556   return (intp *) t;
 557 }
 558
 559 typedef double doublep;
 560
 561 SWIGINTERN doublep *new_doublep(){
 562   return new double();
 563 }
 564 SWIGINTERN void delete_doublep(doublep *self){
 565   if (self) delete self;
 566 }
 567 SWIGINTERN void doublep_assign(doublep *self,double value){
 568   *self = value;
 569 }
 570 SWIGINTERN double doublep_value(doublep *self){
 571   return *self;
 572 }
 573 SWIGINTERN double *doublep_cast(doublep *self){
 574   return self;
 575 }
 576 SWIGINTERN doublep *doublep_frompointer(double *t){
 577   return (doublep *) t;
 578 }
 579
 580 typedef unsigned int uintp;
 581
 582 SWIGINTERN uintp *new_uintp(){
 583   return new unsigned int();
 584 }
 585 SWIGINTERN void delete_uintp(uintp *self){
 586   if (self) delete self;
 587 }
 588 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 589   *self = value;
 590 }
 591 SWIGINTERN unsigned int uintp_value(uintp *self){
 592   return *self;
 593 }
 594 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 595   return self;
 596 }
 597 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 598   return (uintp *) t;
 599 }
 600
 601 typedef unsigned short ushortp;
 602
 603 SWIGINTERN ushortp *new_ushortp(){
 604   return new unsigned short();
 605 }
 606 SWIGINTERN void delete_ushortp(ushortp *self){
 607   if (self) delete self;
 608 }
 609 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 610   *self = value;
 611 }
 612 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 613   return *self;
 614 }
 615 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 616   return self;
 617 }
 618 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 619   return (ushortp *) t;
 620 }
 621
 622 unsigned int int_to_uint(int x) {
 623    return (unsigned int) x;
 624 }
 625
 626
 627 using namespace Dali;
 628 using namespace Dali::Toolkit;
 629
 630 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 631 {
 632   bool result = false;
 633   try
 634   {
 635     // C++ code. DALi uses Handle <-> Body design pattern.
 636     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 637     // Handles in DALi can be converted into a boolean type
 638     // to check if the handle has a valid body attached to it.
 639     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 640     if( *self )
 641     {
 642       result = true;
 643     }
 644     else
 645     {
 646       result = false;
 647     }
 648   }
 649   catch (std::out_of_range& e)
 650   {
 651     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 652     return 0;
 653   }
 654   catch (std::exception& e)
 655   {
 656     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 657     return 0;
 658   }
 659   catch (DaliException e)
 660   {
 661     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 662     return 0;
 663   }
 664   catch (...)
 665   {
 666     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 667     return 0;
 668   }
 669   return result;
 670 }
 671
 672 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 673 {
 674   bool result = false;
 675   try
 676   {
 677     // C++ code. Check if two handles reference the same implemtion
 678     if( *self == rhs)
 679     {
 680       result = true;
 681     }
 682     else
 683     {
 684       result = false;
 685     }
 686   }
 687   catch (std::out_of_range& e)
 688   {
 689     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 690     return 0;
 691   }
 692   catch (std::exception& e)
 693   {
 694     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 695     return 0;
 696   }
 697   catch (DaliException e)
 698   {
 699     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 700     return 0;
 701   }
 702   catch (...)
 703   {
 704     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 705     return 0;
 706   }
 707   return result;
 708 }
 709
 710
 711 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 712      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 713    }
 714 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){
 715      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 716    }
 717 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 718         std::vector< Dali::TouchPoint >* pv = 0;
 719         if (capacity >= 0) {
 720           pv = new std::vector< Dali::TouchPoint >();
 721           pv->reserve(capacity);
 722        } else {
 723           throw std::out_of_range("capacity");
 724        }
 725        return pv;
 726       }
 727 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 728         if (index>=0 && index<(int)self->size())
 729           return (*self)[index];
 730         else
 731           throw std::out_of_range("index");
 732       }
 733 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 734         if (index>=0 && index<(int)self->size())
 735           return (*self)[index];
 736         else
 737           throw std::out_of_range("index");
 738       }
 739 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 740         if (index>=0 && index<(int)self->size())
 741           (*self)[index] = val;
 742         else
 743           throw std::out_of_range("index");
 744       }
 745 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 746         self->insert(self->end(), values.begin(), values.end());
 747       }
 748 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 749         if (index < 0)
 750           throw std::out_of_range("index");
 751         if (count < 0)
 752           throw std::out_of_range("count");
 753         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 754           throw std::invalid_argument("invalid range");
 755         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 756       }
 757 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 758         if (index>=0 && index<(int)self->size()+1)
 759           self->insert(self->begin()+index, x);
 760         else
 761           throw std::out_of_range("index");
 762       }
 763 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 764         if (index>=0 && index<(int)self->size()+1)
 765           self->insert(self->begin()+index, values.begin(), values.end());
 766         else
 767           throw std::out_of_range("index");
 768       }
 769 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 770         if (index>=0 && index<(int)self->size())
 771           self->erase(self->begin() + index);
 772         else
 773           throw std::out_of_range("index");
 774       }
 775 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 776         if (index < 0)
 777           throw std::out_of_range("index");
 778         if (count < 0)
 779           throw std::out_of_range("count");
 780         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 781           throw std::invalid_argument("invalid range");
 782         self->erase(self->begin()+index, self->begin()+index+count);
 783       }
 784 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 785         if (count < 0)
 786           throw std::out_of_range("count");
 787         return new std::vector< Dali::TouchPoint >(count, value);
 788       }
 789 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 790         std::reverse(self->begin(), self->end());
 791       }
 792 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 793         if (index < 0)
 794           throw std::out_of_range("index");
 795         if (count < 0)
 796           throw std::out_of_range("count");
 797         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 798           throw std::invalid_argument("invalid range");
 799         std::reverse(self->begin()+index, self->begin()+index+count);
 800       }
 801 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 802         if (index < 0)
 803           throw std::out_of_range("index");
 804         if (index+values.size() > self->size())
 805           throw std::out_of_range("index");
 806         std::copy(values.begin(), values.end(), self->begin()+index);
 807       }
 808 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 809          return self->Empty();
 810       }
 811 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 812         return self->GetConnectionCount();
 813       }
 814 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 815           self->Connect( func );
 816       }
 817 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 818           self->Disconnect( func );
 819       }
 820 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 821           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 822 /*@SWIG@*/ self->Emit( arg );
 823       }
 824 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 825          return self->Empty();
 826       }
 827 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 828         return self->GetConnectionCount();
 829       }
 830 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 831           self->Connect( func );
 832       }
 833 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 834           self->Disconnect( func );
 835       }
 836 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 837           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 838 /*@SWIG@*/ self->Emit( arg );
 839       }
 840 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 841          return self->Empty();
 842       }
 843 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){
 844         return self->GetConnectionCount();
 845       }
 846 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 *)){
 847           self->Connect( func );
 848       }
 849 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 *)){
 850           self->Disconnect( func );
 851       }
 852 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){
 853           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 854 /*@SWIG@*/ self->Emit( arg );
 855       }
 856 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 857          return self->Empty();
 858       }
 859 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 860         return self->GetConnectionCount();
 861       }
 862 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 863           self->Connect( func );
 864       }
 865 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 866           self->Disconnect( func );
 867       }
 868 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 869           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 870 /*@SWIG@*/ self->Emit( arg );
 871       }
 872 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 873          return self->Empty();
 874       }
 875 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 876         return self->GetConnectionCount();
 877       }
 878 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 879           self->Connect( func );
 880       }
 881 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 882           self->Disconnect( func );
 883       }
 884 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 885           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 886 /*@SWIG@*/ self->Emit( arg );
 887       }
 888 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){
 889          return self->Empty();
 890       }
 891 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){
 892         return self->GetConnectionCount();
 893       }
 894 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 &)){
 895         self->Connect( func );
 896       }
 897 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 &)){
 898         self->Disconnect( func );
 899       }
 900 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){
 901         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 902 /*@SWIG@*/ self->Emit( arg1, arg2 );
 903       }
 904 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){
 905          return self->Empty();
 906       }
 907 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){
 908         return self->GetConnectionCount();
 909       }
 910 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 &)){
 911         self->Connect( func );
 912       }
 913 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 &)){
 914         self->Disconnect( func );
 915       }
 916 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){
 917         return self->Emit( arg1, arg2 );
 918       }
 919 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){
 920          return self->Empty();
 921       }
 922 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){
 923         return self->GetConnectionCount();
 924       }
 925 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 &)){
 926         self->Connect( func );
 927       }
 928 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 &)){
 929         self->Disconnect( func );
 930       }
 931 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){
 932         return self->Emit( arg1, arg2 );
 933       }
 934 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){
 935          return self->Empty();
 936       }
 937 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){
 938         return self->GetConnectionCount();
 939       }
 940 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 &)){
 941         self->Connect( func );
 942       }
 943 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 &)){
 944         self->Disconnect( func );
 945       }
 946 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){
 947         return self->Emit( arg1, arg2 );
 948       }
 949 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 950          return self->Empty();
 951       }
 952 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 953         return self->GetConnectionCount();
 954       }
 955 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 956           self->Connect( func );
 957       }
 958 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 959           self->Disconnect( func );
 960       }
 961 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 962           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 963 /*@SWIG@*/ self->Emit( arg );
 964       }
 965 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 966          return self->Empty();
 967       }
 968 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){
 969         return self->GetConnectionCount();
 970       }
 971 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 &)){
 972           self->Connect( func );
 973       }
 974 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 &)){
 975           self->Disconnect( func );
 976       }
 977 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){
 978           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 979 /*@SWIG@*/ self->Emit( arg );
 980       }
 981 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 982          return self->Empty();
 983       }
 984 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){
 985         return self->GetConnectionCount();
 986       }
 987 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 &)){
 988           self->Connect( func );
 989       }
 990 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 &)){
 991           self->Disconnect( func );
 992       }
 993 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){
 994           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 995 /*@SWIG@*/ self->Emit( arg );
 996       }
 997 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 998          return self->Empty();
 999       }
1000 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){
1001         return self->GetConnectionCount();
1002       }
1003 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 &)){
1004           self->Connect( func );
1005       }
1006 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 &)){
1007           self->Disconnect( func );
1008       }
1009 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){
1010           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1011 /*@SWIG@*/ self->Emit( arg );
1012       }
1013 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){
1014          return self->Empty();
1015       }
1016 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){
1017         return self->GetConnectionCount();
1018       }
1019 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 &)){
1020         self->Connect( func );
1021       }
1022 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 &)){
1023         self->Disconnect( func );
1024       }
1025 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){
1026         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1027 /*@SWIG@*/ self->Emit( arg1, arg2 );
1028       }
1029 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){
1030          return self->Empty();
1031       }
1032 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){
1033         return self->GetConnectionCount();
1034       }
1035 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 &)){
1036         self->Connect( func );
1037       }
1038 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 &)){
1039         self->Disconnect( func );
1040       }
1041 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){
1042         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1043 /*@SWIG@*/ self->Emit( arg1, arg2 );
1044       }
1045 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){
1046          return self->Empty();
1047       }
1048 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){
1049         return self->GetConnectionCount();
1050       }
1051 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 &)){
1052         self->Connect( func );
1053       }
1054 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 &)){
1055         self->Disconnect( func );
1056       }
1057 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){
1058         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1059 /*@SWIG@*/ self->Emit( arg1, arg2 );
1060       }
1061 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1062          return self->Empty();
1063       }
1064 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1065         return self->GetConnectionCount();
1066       }
1067 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1068           self->Connect( func );
1069       }
1070 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1071           self->Disconnect( func );
1072       }
1073 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1074           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1075 /*@SWIG@*/ self->Emit( arg );
1076       }
1077 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){
1078          return self->Empty();
1079       }
1080 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){
1081         return self->GetConnectionCount();
1082       }
1083 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)){
1084           return self->Connect( func );
1085       }
1086 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)){
1087           self->Disconnect( func );
1088       }
1089 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){
1090           self->Emit( arg1, arg3 );
1091       }
1092 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){
1093          return self->Empty();
1094       }
1095 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){
1096         return self->GetConnectionCount();
1097       }
1098 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)){
1099           return self->Connect( func );
1100       }
1101 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)){
1102           self->Disconnect( func );
1103       }
1104 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){
1105           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1106 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1107       }
1108
1109 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1110          return self->Empty();
1111       }
1112 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1113         return self->GetConnectionCount();
1114       }
1115 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1116           self->Connect( func );
1117       }
1118 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1119           self->Disconnect( func );
1120       }
1121 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1122           return self->Emit();
1123       }
1124
1125 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1126         std::vector< unsigned int >* pv = 0;
1127         if (capacity >= 0) {
1128           pv = new std::vector< unsigned int >();
1129           pv->reserve(capacity);
1130        } else {
1131           throw std::out_of_range("capacity");
1132        }
1133        return pv;
1134       }
1135 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1136         if (index>=0 && index<(int)self->size())
1137           return (*self)[index];
1138         else
1139           throw std::out_of_range("index");
1140       }
1141 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1142         if (index>=0 && index<(int)self->size())
1143           return (*self)[index];
1144         else
1145           throw std::out_of_range("index");
1146       }
1147 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1148         if (index>=0 && index<(int)self->size())
1149           (*self)[index] = val;
1150         else
1151           throw std::out_of_range("index");
1152       }
1153 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1154         self->insert(self->end(), values.begin(), values.end());
1155       }
1156 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1157         if (index < 0)
1158           throw std::out_of_range("index");
1159         if (count < 0)
1160           throw std::out_of_range("count");
1161         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1162           throw std::invalid_argument("invalid range");
1163         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1164       }
1165 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1166         if (index>=0 && index<(int)self->size()+1)
1167           self->insert(self->begin()+index, x);
1168         else
1169           throw std::out_of_range("index");
1170       }
1171 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1172         if (index>=0 && index<(int)self->size()+1)
1173           self->insert(self->begin()+index, values.begin(), values.end());
1174         else
1175           throw std::out_of_range("index");
1176       }
1177 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1178         if (index>=0 && index<(int)self->size())
1179           self->erase(self->begin() + index);
1180         else
1181           throw std::out_of_range("index");
1182       }
1183 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1184         if (index < 0)
1185           throw std::out_of_range("index");
1186         if (count < 0)
1187           throw std::out_of_range("count");
1188         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1189           throw std::invalid_argument("invalid range");
1190         self->erase(self->begin()+index, self->begin()+index+count);
1191       }
1192 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1193         if (count < 0)
1194           throw std::out_of_range("count");
1195         return new std::vector< unsigned int >(count, value);
1196       }
1197 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1198         std::reverse(self->begin(), self->end());
1199       }
1200 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1201         if (index < 0)
1202           throw std::out_of_range("index");
1203         if (count < 0)
1204           throw std::out_of_range("count");
1205         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1206           throw std::invalid_argument("invalid range");
1207         std::reverse(self->begin()+index, self->begin()+index+count);
1208       }
1209 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1210         if (index < 0)
1211           throw std::out_of_range("index");
1212         if (index+values.size() > self->size())
1213           throw std::out_of_range("index");
1214         std::copy(values.begin(), values.end(), self->begin()+index);
1215       }
1216 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1217         return std::find(self->begin(), self->end(), value) != self->end();
1218       }
1219 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1220         int index = -1;
1221         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1222         if (it != self->end())
1223           index = (int)(it - self->begin());
1224         return index;
1225       }
1226 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1227         int index = -1;
1228         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1229         if (rit != self->rend())
1230           index = (int)(self->rend() - 1 - rit);
1231         return index;
1232       }
1233 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1234         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1235         if (it != self->end()) {
1236           self->erase(it);
1237           return true;
1238         }
1239         return false;
1240       }
1241 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){
1242         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1243         if (capacity >= 0) {
1244           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1245           pv->reserve(capacity);
1246        } else {
1247           throw std::out_of_range("capacity");
1248        }
1249        return pv;
1250       }
1251 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){
1252         if (index>=0 && index<(int)self->size())
1253           return (*self)[index];
1254         else
1255           throw std::out_of_range("index");
1256       }
1257 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){
1258         if (index>=0 && index<(int)self->size())
1259           return (*self)[index];
1260         else
1261           throw std::out_of_range("index");
1262       }
1263 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){
1264         if (index>=0 && index<(int)self->size())
1265           (*self)[index] = val;
1266         else
1267           throw std::out_of_range("index");
1268       }
1269 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){
1270         self->insert(self->end(), values.begin(), values.end());
1271       }
1272 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){
1273         if (index < 0)
1274           throw std::out_of_range("index");
1275         if (count < 0)
1276           throw std::out_of_range("count");
1277         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1278           throw std::invalid_argument("invalid range");
1279         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1280       }
1281 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){
1282         if (index>=0 && index<(int)self->size()+1)
1283           self->insert(self->begin()+index, x);
1284         else
1285           throw std::out_of_range("index");
1286       }
1287 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){
1288         if (index>=0 && index<(int)self->size()+1)
1289           self->insert(self->begin()+index, values.begin(), values.end());
1290         else
1291           throw std::out_of_range("index");
1292       }
1293 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){
1294         if (index>=0 && index<(int)self->size())
1295           self->erase(self->begin() + index);
1296         else
1297           throw std::out_of_range("index");
1298       }
1299 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){
1300         if (index < 0)
1301           throw std::out_of_range("index");
1302         if (count < 0)
1303           throw std::out_of_range("count");
1304         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1305           throw std::invalid_argument("invalid range");
1306         self->erase(self->begin()+index, self->begin()+index+count);
1307       }
1308 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){
1309         if (count < 0)
1310           throw std::out_of_range("count");
1311         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1312       }
1313 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){
1314         std::reverse(self->begin(), self->end());
1315       }
1316 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){
1317         if (index < 0)
1318           throw std::out_of_range("index");
1319         if (count < 0)
1320           throw std::out_of_range("count");
1321         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1322           throw std::invalid_argument("invalid range");
1323         std::reverse(self->begin()+index, self->begin()+index+count);
1324       }
1325 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){
1326         if (index < 0)
1327           throw std::out_of_range("index");
1328         if (index+values.size() > self->size())
1329           throw std::out_of_range("index");
1330         std::copy(values.begin(), values.end(), self->begin()+index);
1331       }
1332 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1333         std::vector< Dali::Actor >* pv = 0;
1334         if (capacity >= 0) {
1335           pv = new std::vector< Dali::Actor >();
1336           pv->reserve(capacity);
1337        } else {
1338           throw std::out_of_range("capacity");
1339        }
1340        return pv;
1341       }
1342 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1343         if (index>=0 && index<(int)self->size())
1344           return (*self)[index];
1345         else
1346           throw std::out_of_range("index");
1347       }
1348 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1349         if (index>=0 && index<(int)self->size())
1350           return (*self)[index];
1351         else
1352           throw std::out_of_range("index");
1353       }
1354 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1355         if (index>=0 && index<(int)self->size())
1356           (*self)[index] = val;
1357         else
1358           throw std::out_of_range("index");
1359       }
1360 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1361         self->insert(self->end(), values.begin(), values.end());
1362       }
1363 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1364         if (index < 0)
1365           throw std::out_of_range("index");
1366         if (count < 0)
1367           throw std::out_of_range("count");
1368         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1369           throw std::invalid_argument("invalid range");
1370         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1371       }
1372 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1373         if (index>=0 && index<(int)self->size()+1)
1374           self->insert(self->begin()+index, x);
1375         else
1376           throw std::out_of_range("index");
1377       }
1378 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1379         if (index>=0 && index<(int)self->size()+1)
1380           self->insert(self->begin()+index, values.begin(), values.end());
1381         else
1382           throw std::out_of_range("index");
1383       }
1384 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1385         if (index>=0 && index<(int)self->size())
1386           self->erase(self->begin() + index);
1387         else
1388           throw std::out_of_range("index");
1389       }
1390 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1391         if (index < 0)
1392           throw std::out_of_range("index");
1393         if (count < 0)
1394           throw std::out_of_range("count");
1395         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1396           throw std::invalid_argument("invalid range");
1397         self->erase(self->begin()+index, self->begin()+index+count);
1398       }
1399 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1400         if (count < 0)
1401           throw std::out_of_range("count");
1402         return new std::vector< Dali::Actor >(count, value);
1403       }
1404 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1405         std::reverse(self->begin(), self->end());
1406       }
1407 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1408         if (index < 0)
1409           throw std::out_of_range("index");
1410         if (count < 0)
1411           throw std::out_of_range("count");
1412         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1413           throw std::invalid_argument("invalid range");
1414         std::reverse(self->begin()+index, self->begin()+index+count);
1415       }
1416 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1417         if (index < 0)
1418           throw std::out_of_range("index");
1419         if (index+values.size() > self->size())
1420           throw std::out_of_range("index");
1421         std::copy(values.begin(), values.end(), self->begin()+index);
1422       }
1423 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1424          return self->Empty();
1425       }
1426 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1427         return self->GetConnectionCount();
1428       }
1429 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 &)){
1430           self->Connect( func );
1431       }
1432 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 &)){
1433           self->Disconnect( func );
1434       }
1435 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){
1436           return self->Emit( arg );
1437       }
1438 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){
1439          return self->Empty();
1440       }
1441 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){
1442         return self->GetConnectionCount();
1443       }
1444 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)){
1445         self->Connect( func );
1446       }
1447 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)){
1448         self->Disconnect( func );
1449       }
1450 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){
1451         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1452 /*@SWIG@*/ self->Emit( arg1, arg2 );
1453       }
1454 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1455          return self->Empty();
1456       }
1457 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){
1458         return self->GetConnectionCount();
1459       }
1460 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)){
1461         self->Connect( func );
1462       }
1463 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)){
1464         self->Disconnect( func );
1465       }
1466 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){
1467         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1468 /*@SWIG@*/ self->Emit( arg1, arg2 );
1469       }
1470 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1471          return self->Empty();
1472       }
1473 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1474         return self->GetConnectionCount();
1475       }
1476 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)){
1477         self->Connect( func );
1478       }
1479 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)){
1480         self->Disconnect( func );
1481       }
1482 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){
1483         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1484 /*@SWIG@*/ self->Emit( arg1, arg2 );
1485       }
1486 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){
1487          return self->Empty();
1488       }
1489 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){
1490         return self->GetConnectionCount();
1491       }
1492 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)){
1493         self->Connect( func );
1494       }
1495 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)){
1496         self->Disconnect( func );
1497       }
1498 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){
1499         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1500 /*@SWIG@*/ self->Emit( arg1, arg2 );
1501       }
1502 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1503          return self->Empty();
1504       }
1505 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1506         return self->GetConnectionCount();
1507       }
1508 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)){
1509           self->Connect( func );
1510       }
1511 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)){
1512           self->Disconnect( func );
1513       }
1514 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1515           return self->Emit( arg );
1516       }
1517 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1518          return self->Empty();
1519       }
1520 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1521         return self->GetConnectionCount();
1522       }
1523 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)){
1524           self->Connect( func );
1525       }
1526 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)){
1527           self->Disconnect( func );
1528       }
1529 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1530           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1531 /*@SWIG@*/ self->Emit( arg );
1532       }
1533 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){
1534          return self->Empty();
1535       }
1536 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){
1537         return self->GetConnectionCount();
1538       }
1539 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)){
1540           return self->Connect( func );
1541       }
1542 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)){
1543           self->Disconnect( func );
1544       }
1545 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){
1546           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1547 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1548       }
1549 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1550          return self->Empty();
1551       }
1552 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1553         return self->GetConnectionCount();
1554       }
1555 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)){
1556           self->Connect( func );
1557       }
1558 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)){
1559           self->Disconnect( func );
1560       }
1561 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1562           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1563 /*@SWIG@*/ self->Emit( arg );
1564       }
1565 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){
1566          return self->Empty();
1567       }
1568 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){
1569         return self->GetConnectionCount();
1570       }
1571 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)){
1572           return self->Connect( func );
1573       }
1574 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)){
1575           self->Disconnect( func );
1576       }
1577 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){
1578           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1579 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1580       }
1581 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){
1582          return self->Empty();
1583       }
1584 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){
1585         return self->GetConnectionCount();
1586       }
1587 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 &)){
1588           self->Connect( func );
1589       }
1590 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 &)){
1591           self->Disconnect( func );
1592       }
1593 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){
1594           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1595 /*@SWIG@*/ self->Emit( arg );
1596       }
1597 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1598          return self->Empty();
1599       }
1600 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){
1601         return self->GetConnectionCount();
1602       }
1603 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 &)){
1604           self->Connect( func );
1605       }
1606 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 &)){
1607           self->Disconnect( func );
1608       }
1609 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){
1610           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1611 /*@SWIG@*/ self->Emit( arg );
1612       }
1613
1614
1615 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){
1616          return self->Empty();
1617       }
1618 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){
1619         return self->GetConnectionCount();
1620       }
1621 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 &)){
1622         self->Connect( func );
1623       }
1624 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 &)){
1625         self->Disconnect( func );
1626       }
1627 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){
1628         return self->Emit( arg1, arg2 );
1629       }
1630 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1631          return self->Empty();
1632       }
1633 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1634         return self->GetConnectionCount();
1635       }
1636 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)){
1637           self->Connect( func );
1638       }
1639 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)){
1640           self->Disconnect( func );
1641       }
1642 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1643           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1644 /*@SWIG@*/ self->Emit( arg );
1645       }
1646 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1647          return self->Empty();
1648       }
1649 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1650         return self->GetConnectionCount();
1651       }
1652 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 &)){
1653           self->Connect( func );
1654       }
1655 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 &)){
1656           self->Disconnect( func );
1657       }
1658 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){
1659           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1660 /*@SWIG@*/ self->Emit( arg );
1661       }
1662 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1663          return self->Empty();
1664       }
1665 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){
1666         return self->GetConnectionCount();
1667       }
1668 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)){
1669         self->Connect( func );
1670       }
1671 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)){
1672         self->Disconnect( func );
1673       }
1674 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){
1675         return self->Emit( arg1, arg2 );
1676       }
1677 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1678          return self->Empty();
1679       }
1680 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){
1681         return self->GetConnectionCount();
1682       }
1683 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)){
1684         self->Connect( func );
1685       }
1686 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)){
1687         self->Disconnect( func );
1688       }
1689 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){
1690         return self->Emit( arg1, arg2 );
1691       }
1692
1693 /* ---------------------------------------------------
1694  * C++ director class methods
1695  * --------------------------------------------------- */
1696
1697 #include "dali_wrap.h"
1698
1699 /*
1700  *  Widget director
1701  */
1702 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1703   swig_init_callbacks();
1704 }
1705
1706 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1707 }
1708
1709 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1710   char * jcontentInfo = 0 ;
1711   void * jwindow  ;
1712
1713   if (!swig_callbackOnCreate) {
1714     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1715     return;
1716   } else {
1717     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1718     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1719     swig_callbackOnCreate(jcontentInfo, jwindow);
1720   }
1721 }
1722
1723 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1724   char * jcontentInfo = 0 ;
1725   int jtype  ;
1726
1727   if (!swig_callbackOnTerminate) {
1728     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1729     return;
1730   } else {
1731     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1732     jtype = (int)type;
1733     swig_callbackOnTerminate(jcontentInfo, jtype);
1734   }
1735 }
1736
1737 void SwigDirector_WidgetImpl::OnPause() {
1738   if (!swig_callbackOnPause) {
1739     Dali::Internal::Adaptor::Widget::OnPause();
1740     return;
1741   } else {
1742     swig_callbackOnPause();
1743   }
1744 }
1745
1746 void SwigDirector_WidgetImpl::OnResume() {
1747   if (!swig_callbackOnResume) {
1748     Dali::Internal::Adaptor::Widget::OnResume();
1749     return;
1750   } else {
1751     swig_callbackOnResume();
1752   }
1753 }
1754
1755 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1756   void * jwindow  ;
1757
1758   if (!swig_callbackOnResize) {
1759     Dali::Internal::Adaptor::Widget::OnResize(window);
1760     return;
1761   } else {
1762     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1763     swig_callbackOnResize(jwindow);
1764   }
1765 }
1766
1767 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1768   char * jcontentInfo = 0 ;
1769   int jforce  ;
1770
1771   if (!swig_callbackOnUpdate) {
1772     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1773     return;
1774   } else {
1775     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1776     jforce = force;
1777     swig_callbackOnUpdate(jcontentInfo, jforce);
1778   }
1779 }
1780
1781 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1782   void * jslotObserver = 0 ;
1783   void * jcallback = 0 ;
1784
1785   if (!swig_callbackSignalConnected) {
1786     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1787     return;
1788   } else {
1789     jslotObserver = (void *) slotObserver;
1790     jcallback = (void *) callback;
1791     swig_callbackSignalConnected(jslotObserver, jcallback);
1792   }
1793 }
1794
1795 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1796   void * jslotObserver = 0 ;
1797   void * jcallback = 0 ;
1798
1799   if (!swig_callbackSignalDisconnected) {
1800     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1801     return;
1802   } else {
1803     jslotObserver = (void *) slotObserver;
1804     jcallback = (void *) callback;
1805     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1806   }
1807 }
1808
1809 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) {
1810
1811   swig_callbackOnCreate = callbackOnCreate;
1812   swig_callbackOnTerminate = callbackOnTerminate;
1813   swig_callbackOnPause = callbackOnPause;
1814   swig_callbackOnResume = callbackOnResume;
1815   swig_callbackOnResize = callbackOnResize;
1816   swig_callbackOnUpdate = callbackOnUpdate;
1817   swig_callbackSignalConnected = callbackSignalConnected;
1818   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1819 }
1820
1821 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1822   swig_callbackOnCreate = 0;
1823   swig_callbackOnTerminate = 0;
1824   swig_callbackOnPause = 0;
1825   swig_callbackOnResume = 0;
1826   swig_callbackOnResize = 0;
1827   swig_callbackOnUpdate = 0;
1828   swig_callbackSignalConnected = 0;
1829   swig_callbackSignalDisconnected = 0;
1830 }
1831
1832
1833 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1834   swig_init_callbacks();
1835 }
1836
1837 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1838
1839 }
1840
1841
1842 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1843   int jdepth  ;
1844
1845   if (!swig_callbackOnStageConnection) {
1846     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1847     return;
1848   } else {
1849     jdepth = depth;
1850     swig_callbackOnStageConnection(jdepth);
1851   }
1852 }
1853
1854 void SwigDirector_ViewImpl::OnStageDisconnection() {
1855   if (!swig_callbackOnStageDisconnection) {
1856     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1857     return;
1858   } else {
1859     swig_callbackOnStageDisconnection();
1860   }
1861 }
1862
1863 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1864   void * jchild = 0 ;
1865
1866   if (!swig_callbackOnChildAdd) {
1867     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1868     return;
1869   } else {
1870     jchild = (Dali::Actor *) &child;
1871     swig_callbackOnChildAdd(jchild);
1872   }
1873 }
1874
1875 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1876   void * jchild = 0 ;
1877
1878   if (!swig_callbackOnChildRemove) {
1879     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1880     return;
1881   } else {
1882     jchild = (Dali::Actor *) &child;
1883     swig_callbackOnChildRemove(jchild);
1884   }
1885 }
1886
1887 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1888   int jindex  ;
1889   void * jpropertyValue  ;
1890
1891   if (!swig_callbackOnPropertySet) {
1892     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1893     return;
1894   } else {
1895     jindex = index;
1896     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1897     swig_callbackOnPropertySet(jindex, jpropertyValue);
1898   }
1899 }
1900
1901 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1902   void * jtargetSize = 0 ;
1903
1904   if (!swig_callbackOnSizeSet) {
1905     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1906     return;
1907   } else {
1908     jtargetSize = (Dali::Vector3 *) &targetSize;
1909     swig_callbackOnSizeSet(jtargetSize);
1910   }
1911 }
1912
1913 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1914   void * janimation = 0 ;
1915   void * jtargetSize = 0 ;
1916
1917   if (!swig_callbackOnSizeAnimation) {
1918     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1919     return;
1920   } else {
1921     janimation = (Dali::Animation *) &animation;
1922     jtargetSize = (Dali::Vector3 *) &targetSize;
1923     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1924   }
1925 }
1926
1927 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1928   bool c_result = SwigValueInit< bool >() ;
1929   unsigned int jresult = 0 ;
1930   void * jarg0 = 0 ;
1931
1932   if (!swig_callbackOnTouchEvent) {
1933     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1934   } else {
1935     jarg0 = (Dali::TouchEvent *) &event;
1936     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1937     c_result = jresult ? true : false;
1938   }
1939   return c_result;
1940 }
1941
1942 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1943   bool c_result = SwigValueInit< bool >() ;
1944   unsigned int jresult = 0 ;
1945   void * jarg0 = 0 ;
1946
1947   if (!swig_callbackOnHoverEvent) {
1948     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1949   } else {
1950     jarg0 = (Dali::HoverEvent *) &event;
1951     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1952     c_result = jresult ? true : false;
1953   }
1954   return c_result;
1955 }
1956
1957 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1958   bool c_result = SwigValueInit< bool >() ;
1959   unsigned int jresult = 0 ;
1960   void * jarg0 = 0 ;
1961
1962   if (!swig_callbackOnKeyEvent) {
1963     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1964   } else {
1965     jarg0 = (Dali::KeyEvent *) &event;
1966     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1967     c_result = jresult ? true : false;
1968   }
1969   return c_result;
1970 }
1971
1972 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1973   bool c_result = SwigValueInit< bool >() ;
1974   unsigned int jresult = 0 ;
1975   void * jarg0 = 0 ;
1976
1977   if (!swig_callbackOnWheelEvent) {
1978     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1979   } else {
1980     jarg0 = (Dali::WheelEvent *) &event;
1981     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1982     c_result = jresult ? true : false;
1983   }
1984   return c_result;
1985 }
1986
1987 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1988   void * jsize = 0 ;
1989   void * jcontainer = 0 ;
1990
1991   if (!swig_callbackOnRelayout) {
1992     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1993     return;
1994   } else {
1995     jsize = (Dali::Vector2 *) &size;
1996     jcontainer = (Dali::RelayoutContainer *) &container;
1997     swig_callbackOnRelayout(jsize, jcontainer);
1998   }
1999 }
2000
2001 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
2002   int jpolicy  ;
2003   int jdimension  ;
2004
2005   if (!swig_callbackOnSetResizePolicy) {
2006     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
2007     return;
2008   } else {
2009     jpolicy = (int)policy;
2010     jdimension = (int)dimension;
2011     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
2012   }
2013 }
2014
2015 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
2016   Dali::Vector3 c_result ;
2017   void * jresult = 0 ;
2018
2019   if (!swig_callbackGetNaturalSize) {
2020     return Dali::Toolkit::Internal::Control::GetNaturalSize();
2021   } else {
2022     jresult = (void *) swig_callbackGetNaturalSize();
2023     if (!jresult) {
2024       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
2025       return c_result;
2026     }
2027     c_result = *(Dali::Vector3 *)jresult;
2028   }
2029   return c_result;
2030 }
2031
2032 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2033   float c_result = SwigValueInit< float >() ;
2034   float jresult = 0 ;
2035   void * jchild = 0 ;
2036   int jdimension  ;
2037
2038   if (!swig_callbackCalculateChildSize) {
2039     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2040   } else {
2041     jchild = (Dali::Actor *) &child;
2042     jdimension = (int)dimension;
2043     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2044     c_result = (float)jresult;
2045   }
2046   return c_result;
2047 }
2048
2049 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2050   float c_result = SwigValueInit< float >() ;
2051   float jresult = 0 ;
2052   float jwidth  ;
2053
2054   if (!swig_callbackGetHeightForWidth) {
2055     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2056   } else {
2057     jwidth = width;
2058     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2059     c_result = (float)jresult;
2060   }
2061   return c_result;
2062 }
2063
2064 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2065   float c_result = SwigValueInit< float >() ;
2066   float jresult = 0 ;
2067   float jheight  ;
2068
2069   if (!swig_callbackGetWidthForHeight) {
2070     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2071   } else {
2072     jheight = height;
2073     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2074     c_result = (float)jresult;
2075   }
2076   return c_result;
2077 }
2078
2079 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2080   bool c_result = SwigValueInit< bool >() ;
2081   unsigned int jresult = 0 ;
2082   int jdimension  ;
2083
2084   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2085     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2086   } else {
2087     jdimension = (int)dimension;
2088     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2089     c_result = jresult ? true : false;
2090   }
2091   return c_result;
2092 }
2093
2094 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2095   int jdimension  ;
2096
2097   if (!swig_callbackOnCalculateRelayoutSize) {
2098     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2099     return;
2100   } else {
2101     jdimension = (int)dimension;
2102     swig_callbackOnCalculateRelayoutSize(jdimension);
2103   }
2104 }
2105
2106 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2107   float jsize  ;
2108   int jdimension  ;
2109
2110   if (!swig_callbackOnLayoutNegotiated) {
2111     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2112     return;
2113   } else {
2114     jsize = size;
2115     jdimension = (int)dimension;
2116     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2117   }
2118 }
2119
2120 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2121   return Dali::CustomActorImpl::GetExtension();
2122 }
2123
2124 void SwigDirector_ViewImpl::OnInitialize() {
2125   if (!swig_callbackOnInitialize) {
2126     Dali::Toolkit::Internal::Control::OnInitialize();
2127     return;
2128   } else {
2129     swig_callbackOnInitialize();
2130   }
2131 }
2132
2133 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2134   void * jchild = 0 ;
2135
2136   if (!swig_callbackOnControlChildAdd) {
2137     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2138     return;
2139   } else {
2140     jchild = (Dali::Actor *) &child;
2141     swig_callbackOnControlChildAdd(jchild);
2142   }
2143 }
2144
2145 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2146   void * jchild = 0 ;
2147
2148   if (!swig_callbackOnControlChildRemove) {
2149     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2150     return;
2151   } else {
2152     jchild = (Dali::Actor *) &child;
2153     swig_callbackOnControlChildRemove(jchild);
2154   }
2155 }
2156
2157 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2158   void * jstyleManager  ;
2159   int jchange  ;
2160
2161   if (!swig_callbackOnStyleChange) {
2162     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2163     return;
2164   } else {
2165     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2166     jchange = (int)change;
2167     swig_callbackOnStyleChange(jstyleManager, jchange);
2168   }
2169 }
2170
2171 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2172   bool c_result = SwigValueInit< bool >() ;
2173   unsigned int jresult = 0 ;
2174
2175   if (!swig_callbackOnAccessibilityActivated) {
2176     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2177   } else {
2178     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2179     c_result = jresult ? true : false;
2180   }
2181   return c_result;
2182 }
2183
2184 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2185   bool c_result = SwigValueInit< bool >() ;
2186   unsigned int jresult = 0 ;
2187   void * jgesture  ;
2188
2189   if (!swig_callbackOnAccessibilityPan) {
2190     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2191   } else {
2192     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2193     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2194     c_result = jresult ? true : false;
2195   }
2196   return c_result;
2197 }
2198
2199 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2200   bool c_result = SwigValueInit< bool >() ;
2201   unsigned int jresult = 0 ;
2202   void * jtouchEvent = 0 ;
2203
2204   if (!swig_callbackOnAccessibilityTouch) {
2205     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2206   } else {
2207     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2208     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2209     c_result = jresult ? true : false;
2210   }
2211   return c_result;
2212 }
2213
2214 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2215   bool c_result = SwigValueInit< bool >() ;
2216   unsigned int jresult = 0 ;
2217   unsigned int jisIncrease  ;
2218
2219   if (!swig_callbackOnAccessibilityValueChange) {
2220     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2221   } else {
2222     jisIncrease = isIncrease;
2223     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2224     c_result = jresult ? true : false;
2225   }
2226   return c_result;
2227 }
2228
2229 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2230   bool c_result = SwigValueInit< bool >() ;
2231   unsigned int jresult = 0 ;
2232
2233   if (!swig_callbackOnAccessibilityZoom) {
2234     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2235   } else {
2236     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2237     c_result = jresult ? true : false;
2238   }
2239   return c_result;
2240 }
2241
2242 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2243   if (!swig_callbackOnKeyInputFocusGained) {
2244     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2245     return;
2246   } else {
2247     swig_callbackOnKeyInputFocusGained();
2248   }
2249 }
2250
2251 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2252   if (!swig_callbackOnKeyInputFocusLost) {
2253     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2254     return;
2255   } else {
2256     swig_callbackOnKeyInputFocusLost();
2257   }
2258 }
2259
2260 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2261   Dali::Actor c_result ;
2262   void * jresult = 0 ;
2263   void * jcurrentFocusedActor  ;
2264   int jdirection  ;
2265   unsigned int jloopEnabled  ;
2266
2267   if (!swig_callbackGetNextKeyboardFocusableActor) {
2268     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2269   } else {
2270     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2271     jdirection = (int)direction;
2272     jloopEnabled = loopEnabled;
2273     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2274     if (!jresult) {
2275       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2276       return c_result;
2277     }
2278     c_result = *(Dali::Actor *)jresult;
2279   }
2280   return c_result;
2281 }
2282
2283 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2284   void * jcommitedFocusableActor  ;
2285
2286   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2287     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2288     return;
2289   } else {
2290     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2291     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2292   }
2293 }
2294
2295 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2296   bool c_result = SwigValueInit< bool >() ;
2297   unsigned int jresult = 0 ;
2298
2299   if (!swig_callbackOnKeyboardEnter) {
2300     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2301   } else {
2302     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2303     c_result = jresult ? true : false;
2304   }
2305   return c_result;
2306 }
2307
2308 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2309   void * jpinch = 0 ;
2310
2311   if (!swig_callbackOnPinch) {
2312     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2313     return;
2314   } else {
2315     jpinch = (Dali::PinchGesture *) &pinch;
2316     swig_callbackOnPinch(jpinch);
2317   }
2318 }
2319
2320 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2321   void * jpan = 0 ;
2322
2323   if (!swig_callbackOnPan) {
2324     Dali::Toolkit::Internal::Control::OnPan(pan);
2325     return;
2326   } else {
2327     jpan = (Dali::PanGesture *) &pan;
2328     swig_callbackOnPan(jpan);
2329   }
2330 }
2331
2332 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2333   void * jtap = 0 ;
2334
2335   if (!swig_callbackOnTap) {
2336     Dali::Toolkit::Internal::Control::OnTap(tap);
2337     return;
2338   } else {
2339     jtap = (Dali::TapGesture *) &tap;
2340     swig_callbackOnTap(jtap);
2341   }
2342 }
2343
2344 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2345   void * jlongPress = 0 ;
2346
2347   if (!swig_callbackOnLongPress) {
2348     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2349     return;
2350   } else {
2351     jlongPress = (Dali::LongPressGesture *) &longPress;
2352     swig_callbackOnLongPress(jlongPress);
2353   }
2354 }
2355
2356 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2357   void * jslotObserver = 0 ;
2358   void * jcallback = 0 ;
2359
2360   if (!swig_callbackSignalConnected) {
2361     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2362     return;
2363   } else {
2364     jslotObserver = (void *) slotObserver;
2365     jcallback = (void *) callback;
2366     swig_callbackSignalConnected(jslotObserver, jcallback);
2367   }
2368 }
2369
2370 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2371   void * jslotObserver = 0 ;
2372   void * jcallback = 0 ;
2373
2374   if (!swig_callbackSignalDisconnected) {
2375     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2376     return;
2377   } else {
2378     jslotObserver = (void *) slotObserver;
2379     jcallback = (void *) callback;
2380     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2381   }
2382 }
2383
2384 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2385   return Dali::Toolkit::Internal::Control::GetControlExtension();
2386 }
2387
2388 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) {
2389   swig_callbackOnStageConnection = callbackOnStageConnection;
2390   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2391   swig_callbackOnChildAdd = callbackOnChildAdd;
2392   swig_callbackOnChildRemove = callbackOnChildRemove;
2393   swig_callbackOnPropertySet = callbackOnPropertySet;
2394   swig_callbackOnSizeSet = callbackOnSizeSet;
2395   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2396   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2397   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2398   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2399   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2400   swig_callbackOnRelayout = callbackOnRelayout;
2401   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2402   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2403   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2404   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2405   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2406   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2407   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2408   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2409   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2410   swig_callbackOnInitialize = callbackOnInitialize;
2411   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2412   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2413   swig_callbackOnStyleChange = callbackOnStyleChange;
2414   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2415   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2416   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2417   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2418   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2419   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2420   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2421   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2422   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2423   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2424   swig_callbackOnPinch = callbackOnPinch;
2425   swig_callbackOnPan = callbackOnPan;
2426   swig_callbackOnTap = callbackOnTap;
2427   swig_callbackOnLongPress = callbackOnLongPress;
2428   swig_callbackSignalConnected = callbackSignalConnected;
2429   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2430 }
2431
2432 void SwigDirector_ViewImpl::swig_init_callbacks() {
2433   swig_callbackOnStageConnection = 0;
2434   swig_callbackOnStageDisconnection = 0;
2435   swig_callbackOnChildAdd = 0;
2436   swig_callbackOnChildRemove = 0;
2437   swig_callbackOnPropertySet = 0;
2438   swig_callbackOnSizeSet = 0;
2439   swig_callbackOnSizeAnimation = 0;
2440   swig_callbackOnTouchEvent = 0;
2441   swig_callbackOnHoverEvent = 0;
2442   swig_callbackOnKeyEvent = 0;
2443   swig_callbackOnWheelEvent = 0;
2444   swig_callbackOnRelayout = 0;
2445   swig_callbackOnSetResizePolicy = 0;
2446   swig_callbackGetNaturalSize = 0;
2447   swig_callbackCalculateChildSize = 0;
2448   swig_callbackGetHeightForWidth = 0;
2449   swig_callbackGetWidthForHeight = 0;
2450   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2451   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2452   swig_callbackOnCalculateRelayoutSize = 0;
2453   swig_callbackOnLayoutNegotiated = 0;
2454   swig_callbackOnInitialize = 0;
2455   swig_callbackOnControlChildAdd = 0;
2456   swig_callbackOnControlChildRemove = 0;
2457   swig_callbackOnStyleChange = 0;
2458   swig_callbackOnAccessibilityActivated = 0;
2459   swig_callbackOnAccessibilityPan = 0;
2460   swig_callbackOnAccessibilityTouch = 0;
2461   swig_callbackOnAccessibilityValueChange = 0;
2462   swig_callbackOnAccessibilityZoom = 0;
2463   swig_callbackOnKeyInputFocusGained = 0;
2464   swig_callbackOnKeyInputFocusLost = 0;
2465   swig_callbackGetNextKeyboardFocusableActor = 0;
2466   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2467   swig_callbackOnKeyboardEnter = 0;
2468   swig_callbackOnPinch = 0;
2469   swig_callbackOnPan = 0;
2470   swig_callbackOnTap = 0;
2471   swig_callbackOnLongPress = 0;
2472   swig_callbackSignalConnected = 0;
2473   swig_callbackSignalDisconnected = 0;
2474 }
2475
2476 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2477   swig_init_callbacks();
2478 }
2479
2480 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2481
2482 }
2483
2484
2485 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2486   unsigned int c_result = SwigValueInit< unsigned int >() ;
2487   unsigned int jresult = 0 ;
2488
2489   if (!swig_callbackGetNumberOfItems) {
2490     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2491   } else {
2492     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2493     c_result = (unsigned int)jresult;
2494   }
2495   return c_result;
2496 }
2497
2498 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2499   Dali::Actor c_result ;
2500   void * jresult = 0 ;
2501   unsigned int jitemId  ;
2502
2503   if (!swig_callbackNewItem) {
2504     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2505   } else {
2506     jitemId = itemId;
2507     jresult = (void *) swig_callbackNewItem(jitemId);
2508     if (!jresult) {
2509       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2510       return c_result;
2511     }
2512     c_result = *(Dali::Actor *)jresult;
2513   }
2514   return c_result;
2515 }
2516
2517 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2518   unsigned int jitemId  ;
2519   void * jactor  ;
2520
2521   if (!swig_callbackItemReleased) {
2522     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2523     return;
2524   } else {
2525     jitemId = itemId;
2526     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2527     swig_callbackItemReleased(jitemId, jactor);
2528   }
2529 }
2530
2531 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2532   return Dali::Toolkit::ItemFactory::GetExtension();
2533 }
2534
2535 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2536   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2537   swig_callbackNewItem = callbackNewItem;
2538   swig_callbackItemReleased = callbackItemReleased;
2539 }
2540
2541 void SwigDirector_ItemFactory::swig_init_callbacks() {
2542   swig_callbackGetNumberOfItems = 0;
2543   swig_callbackNewItem = 0;
2544   swig_callbackItemReleased = 0;
2545 }
2546
2547 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2548   swig_init_callbacks();
2549 }
2550
2551 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2552
2553 }
2554
2555
2556 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2557   Dali::Actor c_result ;
2558   void * jresult = 0 ;
2559   void * jcurrent  ;
2560   void * jproposed  ;
2561   int jdirection  ;
2562
2563   if (!swig_callbackGetNextFocusableActor) {
2564     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2565   } else {
2566     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2567     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2568     jdirection = (int)direction;
2569     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2570     if (!jresult) {
2571       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__);
2572       return c_result;
2573     }
2574     c_result = *(Dali::Actor *)jresult;
2575   }
2576   return c_result;
2577 }
2578
2579 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2580   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2581 }
2582
2583 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2584   swig_callbackGetNextFocusableActor = 0;
2585 }
2586
2587
2588 #ifdef __cplusplus
2589 extern "C" {
2590 #endif
2591
2592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2593   void * jresult ;
2594   floatp *result = 0 ;
2595
2596   {
2597     try {
2598       result = (floatp *)new_floatp();
2599     } catch (std::out_of_range& e) {
2600       {
2601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2602       };
2603     } catch (std::exception& e) {
2604       {
2605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2606       };
2607     } catch (DaliException e) {
2608       {
2609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2610       };
2611     } catch (...) {
2612       {
2613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2614       };
2615     }
2616   }
2617   jresult = (void *)result;
2618   return jresult;
2619 }
2620
2621
2622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2623   floatp *arg1 = (floatp *) 0 ;
2624
2625   arg1 = (floatp *)jarg1;
2626   {
2627     try {
2628       delete_floatp(arg1);
2629     } catch (std::out_of_range& e) {
2630       {
2631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2632       };
2633     } catch (std::exception& e) {
2634       {
2635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2636       };
2637     } catch (Dali::DaliException e) {
2638       {
2639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2640       };
2641     } catch (...) {
2642       {
2643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2644       };
2645     }
2646   }
2647
2648 }
2649
2650
2651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2652   floatp *arg1 = (floatp *) 0 ;
2653   float arg2 ;
2654
2655   arg1 = (floatp *)jarg1;
2656   arg2 = (float)jarg2;
2657   {
2658     try {
2659       floatp_assign(arg1,arg2);
2660     } catch (std::out_of_range& e) {
2661       {
2662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2663       };
2664     } catch (std::exception& e) {
2665       {
2666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2667       };
2668     } catch (Dali::DaliException e) {
2669       {
2670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2671       };
2672     } catch (...) {
2673       {
2674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2675       };
2676     }
2677   }
2678
2679 }
2680
2681
2682 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2683   float jresult ;
2684   floatp *arg1 = (floatp *) 0 ;
2685   float result;
2686
2687   arg1 = (floatp *)jarg1;
2688   {
2689     try {
2690       result = (float)floatp_value(arg1);
2691     } catch (std::out_of_range& e) {
2692       {
2693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2694       };
2695     } catch (std::exception& e) {
2696       {
2697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2698       };
2699     } catch (DaliException e) {
2700       {
2701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2702       };
2703     } catch (...) {
2704       {
2705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2706       };
2707     }
2708   }
2709   jresult = result;
2710   return jresult;
2711 }
2712
2713
2714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2715   void * jresult ;
2716   floatp *arg1 = (floatp *) 0 ;
2717   float *result = 0 ;
2718
2719   arg1 = (floatp *)jarg1;
2720   {
2721     try {
2722       result = (float *)floatp_cast(arg1);
2723     } catch (std::out_of_range& e) {
2724       {
2725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2726       };
2727     } catch (std::exception& e) {
2728       {
2729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2730       };
2731     } catch (Dali::DaliException e) {
2732       {
2733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2734       };
2735     } catch (...) {
2736       {
2737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2738       };
2739     }
2740   }
2741
2742   jresult = (void *)result;
2743   return jresult;
2744 }
2745
2746
2747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2748   void * jresult ;
2749   float *arg1 = (float *) 0 ;
2750   floatp *result = 0 ;
2751
2752   arg1 = (float *)jarg1;
2753   {
2754     try {
2755       result = (floatp *)floatp_frompointer(arg1);
2756     } catch (std::out_of_range& e) {
2757       {
2758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2759       };
2760     } catch (std::exception& e) {
2761       {
2762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2763       };
2764     } catch (Dali::DaliException e) {
2765       {
2766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2767       };
2768     } catch (...) {
2769       {
2770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2771       };
2772     }
2773   }
2774
2775   jresult = (void *)result;
2776   return jresult;
2777 }
2778
2779
2780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2781   void * jresult ;
2782   intp *result = 0 ;
2783
2784   {
2785     try {
2786       result = (intp *)new_intp();
2787     } catch (std::out_of_range& e) {
2788       {
2789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2790       };
2791     } catch (std::exception& e) {
2792       {
2793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2794       };
2795     } catch (Dali::DaliException e) {
2796       {
2797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2798       };
2799     } catch (...) {
2800       {
2801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2802       };
2803     }
2804   }
2805
2806   jresult = (void *)result;
2807   return jresult;
2808 }
2809
2810
2811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2812   intp *arg1 = (intp *) 0 ;
2813
2814   arg1 = (intp *)jarg1;
2815   {
2816     try {
2817       delete_intp(arg1);
2818     } catch (std::out_of_range& e) {
2819       {
2820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2821       };
2822     } catch (std::exception& e) {
2823       {
2824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2825       };
2826     } catch (Dali::DaliException e) {
2827       {
2828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2829       };
2830     } catch (...) {
2831       {
2832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2833       };
2834     }
2835   }
2836
2837 }
2838
2839
2840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2841   intp *arg1 = (intp *) 0 ;
2842   int arg2 ;
2843
2844   arg1 = (intp *)jarg1;
2845   arg2 = (int)jarg2;
2846   {
2847     try {
2848       intp_assign(arg1,arg2);
2849     } catch (std::out_of_range& e) {
2850       {
2851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2852       };
2853     } catch (std::exception& e) {
2854       {
2855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2856       };
2857     } catch (Dali::DaliException e) {
2858       {
2859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2860       };
2861     } catch (...) {
2862       {
2863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2864       };
2865     }
2866   }
2867
2868 }
2869
2870
2871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2872   int jresult ;
2873   intp *arg1 = (intp *) 0 ;
2874   int result;
2875
2876   arg1 = (intp *)jarg1;
2877   {
2878     try {
2879       result = (int)intp_value(arg1);
2880     } catch (std::out_of_range& e) {
2881       {
2882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2883       };
2884     } catch (std::exception& e) {
2885       {
2886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2887       };
2888     } catch (Dali::DaliException e) {
2889       {
2890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2891       };
2892     } catch (...) {
2893       {
2894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2895       };
2896     }
2897   }
2898
2899   jresult = result;
2900   return jresult;
2901 }
2902
2903
2904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2905   void * jresult ;
2906   intp *arg1 = (intp *) 0 ;
2907   int *result = 0 ;
2908
2909   arg1 = (intp *)jarg1;
2910   {
2911     try {
2912       result = (int *)intp_cast(arg1);
2913     } catch (std::out_of_range& e) {
2914       {
2915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2916       };
2917     } catch (std::exception& e) {
2918       {
2919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2920       };
2921     } catch (Dali::DaliException e) {
2922       {
2923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2924       };
2925     } catch (...) {
2926       {
2927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2928       };
2929     }
2930   }
2931
2932   jresult = (void *)result;
2933   return jresult;
2934 }
2935
2936
2937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2938   void * jresult ;
2939   int *arg1 = (int *) 0 ;
2940   intp *result = 0 ;
2941
2942   arg1 = (int *)jarg1;
2943   {
2944     try {
2945       result = (intp *)intp_frompointer(arg1);
2946     } catch (std::out_of_range& e) {
2947       {
2948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2949       };
2950     } catch (std::exception& e) {
2951       {
2952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2953       };
2954     } catch (Dali::DaliException e) {
2955       {
2956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2957       };
2958     } catch (...) {
2959       {
2960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2961       };
2962     }
2963   }
2964
2965   jresult = (void *)result;
2966   return jresult;
2967 }
2968
2969
2970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2971   void * jresult ;
2972   doublep *result = 0 ;
2973
2974   {
2975     try {
2976       result = (doublep *)new_doublep();
2977     } catch (std::out_of_range& e) {
2978       {
2979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2980       };
2981     } catch (std::exception& e) {
2982       {
2983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2984       };
2985     } catch (Dali::DaliException e) {
2986       {
2987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2988       };
2989     } catch (...) {
2990       {
2991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2992       };
2993     }
2994   }
2995
2996   jresult = (void *)result;
2997   return jresult;
2998 }
2999
3000
3001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
3002   doublep *arg1 = (doublep *) 0 ;
3003
3004   arg1 = (doublep *)jarg1;
3005   {
3006     try {
3007       delete_doublep(arg1);
3008     } catch (std::out_of_range& e) {
3009       {
3010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3011       };
3012     } catch (std::exception& e) {
3013       {
3014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3015       };
3016     } catch (Dali::DaliException e) {
3017       {
3018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3019       };
3020     } catch (...) {
3021       {
3022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3023       };
3024     }
3025   }
3026
3027 }
3028
3029
3030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
3031   doublep *arg1 = (doublep *) 0 ;
3032   double arg2 ;
3033
3034   arg1 = (doublep *)jarg1;
3035   arg2 = (double)jarg2;
3036   {
3037     try {
3038       doublep_assign(arg1,arg2);
3039     } catch (std::out_of_range& e) {
3040       {
3041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3042       };
3043     } catch (std::exception& e) {
3044       {
3045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3046       };
3047     } catch (Dali::DaliException e) {
3048       {
3049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3050       };
3051     } catch (...) {
3052       {
3053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3054       };
3055     }
3056   }
3057
3058 }
3059
3060
3061 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3062   double jresult ;
3063   doublep *arg1 = (doublep *) 0 ;
3064   double result;
3065
3066   arg1 = (doublep *)jarg1;
3067   {
3068     try {
3069       result = (double)doublep_value(arg1);
3070     } catch (std::out_of_range& e) {
3071       {
3072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3073       };
3074     } catch (std::exception& e) {
3075       {
3076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3077       };
3078     } catch (Dali::DaliException e) {
3079       {
3080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3081       };
3082     } catch (...) {
3083       {
3084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3085       };
3086     }
3087   }
3088
3089   jresult = result;
3090   return jresult;
3091 }
3092
3093
3094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3095   void * jresult ;
3096   doublep *arg1 = (doublep *) 0 ;
3097   double *result = 0 ;
3098
3099   arg1 = (doublep *)jarg1;
3100   {
3101     try {
3102       result = (double *)doublep_cast(arg1);
3103     } catch (std::out_of_range& e) {
3104       {
3105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3106       };
3107     } catch (std::exception& e) {
3108       {
3109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3110       };
3111     } catch (Dali::DaliException e) {
3112       {
3113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3114       };
3115     } catch (...) {
3116       {
3117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3118       };
3119     }
3120   }
3121
3122   jresult = (void *)result;
3123   return jresult;
3124 }
3125
3126
3127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3128   void * jresult ;
3129   double *arg1 = (double *) 0 ;
3130   doublep *result = 0 ;
3131
3132   arg1 = (double *)jarg1;
3133   {
3134     try {
3135       result = (doublep *)doublep_frompointer(arg1);
3136     } catch (std::out_of_range& e) {
3137       {
3138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3139       };
3140     } catch (std::exception& e) {
3141       {
3142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3143       };
3144     } catch (Dali::DaliException e) {
3145       {
3146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3147       };
3148     } catch (...) {
3149       {
3150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3151       };
3152     }
3153   }
3154
3155   jresult = (void *)result;
3156   return jresult;
3157 }
3158
3159
3160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3161   void * jresult ;
3162   uintp *result = 0 ;
3163
3164   {
3165     try {
3166       result = (uintp *)new_uintp();
3167     } catch (std::out_of_range& e) {
3168       {
3169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3170       };
3171     } catch (std::exception& e) {
3172       {
3173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3174       };
3175     } catch (Dali::DaliException e) {
3176       {
3177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3178       };
3179     } catch (...) {
3180       {
3181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3182       };
3183     }
3184   }
3185
3186   jresult = (void *)result;
3187   return jresult;
3188 }
3189
3190
3191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3192   uintp *arg1 = (uintp *) 0 ;
3193
3194   arg1 = (uintp *)jarg1;
3195   {
3196     try {
3197       delete_uintp(arg1);
3198     } catch (std::out_of_range& e) {
3199       {
3200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3201       };
3202     } catch (std::exception& e) {
3203       {
3204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3205       };
3206     } catch (Dali::DaliException e) {
3207       {
3208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3209       };
3210     } catch (...) {
3211       {
3212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3213       };
3214     }
3215   }
3216
3217 }
3218
3219
3220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3221   uintp *arg1 = (uintp *) 0 ;
3222   unsigned int arg2 ;
3223
3224   arg1 = (uintp *)jarg1;
3225   arg2 = (unsigned int)jarg2;
3226   {
3227     try {
3228       uintp_assign(arg1,arg2);
3229     } catch (std::out_of_range& e) {
3230       {
3231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3232       };
3233     } catch (std::exception& e) {
3234       {
3235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3236       };
3237     } catch (Dali::DaliException e) {
3238       {
3239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3240       };
3241     } catch (...) {
3242       {
3243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3244       };
3245     }
3246   }
3247
3248 }
3249
3250
3251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3252   unsigned int jresult ;
3253   uintp *arg1 = (uintp *) 0 ;
3254   unsigned int result;
3255
3256   arg1 = (uintp *)jarg1;
3257   {
3258     try {
3259       result = (unsigned int)uintp_value(arg1);
3260     } catch (std::out_of_range& e) {
3261       {
3262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3263       };
3264     } catch (std::exception& e) {
3265       {
3266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3267       };
3268     } catch (Dali::DaliException e) {
3269       {
3270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3271       };
3272     } catch (...) {
3273       {
3274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3275       };
3276     }
3277   }
3278
3279   jresult = result;
3280   return jresult;
3281 }
3282
3283
3284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3285   void * jresult ;
3286   uintp *arg1 = (uintp *) 0 ;
3287   unsigned int *result = 0 ;
3288
3289   arg1 = (uintp *)jarg1;
3290   {
3291     try {
3292       result = (unsigned int *)uintp_cast(arg1);
3293     } catch (std::out_of_range& e) {
3294       {
3295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3296       };
3297     } catch (std::exception& e) {
3298       {
3299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3300       };
3301     } catch (Dali::DaliException e) {
3302       {
3303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3304       };
3305     } catch (...) {
3306       {
3307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3308       };
3309     }
3310   }
3311
3312   jresult = (void *)result;
3313   return jresult;
3314 }
3315
3316
3317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3318   void * jresult ;
3319   unsigned int *arg1 = (unsigned int *) 0 ;
3320   uintp *result = 0 ;
3321
3322   arg1 = (unsigned int *)jarg1;
3323   {
3324     try {
3325       result = (uintp *)uintp_frompointer(arg1);
3326     } catch (std::out_of_range& e) {
3327       {
3328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3329       };
3330     } catch (std::exception& e) {
3331       {
3332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3333       };
3334     } catch (Dali::DaliException e) {
3335       {
3336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3337       };
3338     } catch (...) {
3339       {
3340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3341       };
3342     }
3343   }
3344
3345   jresult = (void *)result;
3346   return jresult;
3347 }
3348
3349
3350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3351   void * jresult ;
3352   ushortp *result = 0 ;
3353
3354   {
3355     try {
3356       result = (ushortp *)new_ushortp();
3357     } catch (std::out_of_range& e) {
3358       {
3359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3360       };
3361     } catch (std::exception& e) {
3362       {
3363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3364       };
3365     } catch (Dali::DaliException e) {
3366       {
3367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3368       };
3369     } catch (...) {
3370       {
3371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3372       };
3373     }
3374   }
3375
3376   jresult = (void *)result;
3377   return jresult;
3378 }
3379
3380
3381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3382   ushortp *arg1 = (ushortp *) 0 ;
3383
3384   arg1 = (ushortp *)jarg1;
3385   {
3386     try {
3387       delete_ushortp(arg1);
3388     } catch (std::out_of_range& e) {
3389       {
3390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3391       };
3392     } catch (std::exception& e) {
3393       {
3394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3395       };
3396     } catch (Dali::DaliException e) {
3397       {
3398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3399       };
3400     } catch (...) {
3401       {
3402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3403       };
3404     }
3405   }
3406
3407 }
3408
3409
3410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3411   ushortp *arg1 = (ushortp *) 0 ;
3412   unsigned short arg2 ;
3413
3414   arg1 = (ushortp *)jarg1;
3415   arg2 = (unsigned short)jarg2;
3416   {
3417     try {
3418       ushortp_assign(arg1,arg2);
3419     } catch (std::out_of_range& e) {
3420       {
3421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3422       };
3423     } catch (std::exception& e) {
3424       {
3425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3426       };
3427     } catch (Dali::DaliException e) {
3428       {
3429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3430       };
3431     } catch (...) {
3432       {
3433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3434       };
3435     }
3436   }
3437
3438 }
3439
3440
3441 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3442   unsigned short jresult ;
3443   ushortp *arg1 = (ushortp *) 0 ;
3444   unsigned short result;
3445
3446   arg1 = (ushortp *)jarg1;
3447   {
3448     try {
3449       result = (unsigned short)ushortp_value(arg1);
3450     } catch (std::out_of_range& e) {
3451       {
3452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3453       };
3454     } catch (std::exception& e) {
3455       {
3456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3457       };
3458     } catch (Dali::DaliException e) {
3459       {
3460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3461       };
3462     } catch (...) {
3463       {
3464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3465       };
3466     }
3467   }
3468
3469   jresult = result;
3470   return jresult;
3471 }
3472
3473
3474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3475   void * jresult ;
3476   ushortp *arg1 = (ushortp *) 0 ;
3477   unsigned short *result = 0 ;
3478
3479   arg1 = (ushortp *)jarg1;
3480   {
3481     try {
3482       result = (unsigned short *)ushortp_cast(arg1);
3483     } catch (std::out_of_range& e) {
3484       {
3485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3486       };
3487     } catch (std::exception& e) {
3488       {
3489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3490       };
3491     } catch (Dali::DaliException e) {
3492       {
3493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3494       };
3495     } catch (...) {
3496       {
3497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3498       };
3499     }
3500   }
3501
3502   jresult = (void *)result;
3503   return jresult;
3504 }
3505
3506
3507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3508   void * jresult ;
3509   unsigned short *arg1 = (unsigned short *) 0 ;
3510   ushortp *result = 0 ;
3511
3512   arg1 = (unsigned short *)jarg1;
3513   {
3514     try {
3515       result = (ushortp *)ushortp_frompointer(arg1);
3516     } catch (std::out_of_range& e) {
3517       {
3518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3519       };
3520     } catch (std::exception& e) {
3521       {
3522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3523       };
3524     } catch (Dali::DaliException e) {
3525       {
3526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3527       };
3528     } catch (...) {
3529       {
3530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3531       };
3532     }
3533   }
3534
3535   jresult = (void *)result;
3536   return jresult;
3537 }
3538
3539
3540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3541   unsigned int jresult ;
3542   int arg1 ;
3543   unsigned int result;
3544
3545   arg1 = (int)jarg1;
3546   {
3547     try {
3548       result = (unsigned int)int_to_uint(arg1);
3549     } catch (std::out_of_range& e) {
3550       {
3551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3552       };
3553     } catch (std::exception& e) {
3554       {
3555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3556       };
3557     } catch (Dali::DaliException e) {
3558       {
3559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3560       };
3561     } catch (...) {
3562       {
3563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3564       };
3565     }
3566   }
3567
3568   jresult = result;
3569   return jresult;
3570 }
3571
3572
3573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3574   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3575
3576   arg1 = (Dali::RefObject *)jarg1;
3577   {
3578     try {
3579       (arg1)->Reference();
3580     } catch (std::out_of_range& e) {
3581       {
3582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3583       };
3584     } catch (std::exception& e) {
3585       {
3586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3587       };
3588     } catch (Dali::DaliException e) {
3589       {
3590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3591       };
3592     } catch (...) {
3593       {
3594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3595       };
3596     }
3597   }
3598
3599 }
3600
3601
3602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3603   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3604
3605   arg1 = (Dali::RefObject *)jarg1;
3606   {
3607     try {
3608       (arg1)->Unreference();
3609     } catch (std::out_of_range& e) {
3610       {
3611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3612       };
3613     } catch (std::exception& e) {
3614       {
3615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3616       };
3617     } catch (Dali::DaliException e) {
3618       {
3619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3620       };
3621     } catch (...) {
3622       {
3623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3624       };
3625     }
3626   }
3627
3628 }
3629
3630
3631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3632   int jresult ;
3633   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3634   int result;
3635
3636   arg1 = (Dali::RefObject *)jarg1;
3637   {
3638     try {
3639       result = (int)(arg1)->ReferenceCount();
3640     } catch (std::out_of_range& e) {
3641       {
3642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3643       };
3644     } catch (std::exception& e) {
3645       {
3646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3647       };
3648     } catch (Dali::DaliException e) {
3649       {
3650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3651       };
3652     } catch (...) {
3653       {
3654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3655       };
3656     }
3657   }
3658
3659   jresult = result;
3660   return jresult;
3661 }
3662
3663
3664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3665   void * jresult ;
3666   Dali::Any *result = 0 ;
3667
3668   {
3669     try {
3670       result = (Dali::Any *)new Dali::Any();
3671     } catch (std::out_of_range& e) {
3672       {
3673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3674       };
3675     } catch (std::exception& e) {
3676       {
3677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3678       };
3679     } catch (Dali::DaliException e) {
3680       {
3681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3682       };
3683     } catch (...) {
3684       {
3685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3686       };
3687     }
3688   }
3689
3690   jresult = (void *)result;
3691   return jresult;
3692 }
3693
3694
3695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3696   Dali::Any *arg1 = (Dali::Any *) 0 ;
3697
3698   arg1 = (Dali::Any *)jarg1;
3699   {
3700     try {
3701       delete arg1;
3702     } catch (std::out_of_range& e) {
3703       {
3704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3705       };
3706     } catch (std::exception& e) {
3707       {
3708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3709       };
3710     } catch (Dali::DaliException e) {
3711       {
3712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3713       };
3714     } catch (...) {
3715       {
3716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3717       };
3718     }
3719   }
3720
3721 }
3722
3723
3724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3725   char *arg1 = (char *) 0 ;
3726
3727   arg1 = (char *)jarg1;
3728   {
3729     try {
3730       Dali::Any::AssertAlways((char const *)arg1);
3731     } catch (std::out_of_range& e) {
3732       {
3733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3734       };
3735     } catch (std::exception& e) {
3736       {
3737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3738       };
3739     } catch (Dali::DaliException e) {
3740       {
3741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3742       };
3743     } catch (...) {
3744       {
3745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3746       };
3747     }
3748   }
3749
3750 }
3751
3752
3753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3754   void * jresult ;
3755   Dali::Any *arg1 = 0 ;
3756   Dali::Any *result = 0 ;
3757
3758   arg1 = (Dali::Any *)jarg1;
3759   if (!arg1) {
3760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3761     return 0;
3762   }
3763   {
3764     try {
3765       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3766     } catch (std::out_of_range& e) {
3767       {
3768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3769       };
3770     } catch (std::exception& e) {
3771       {
3772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3773       };
3774     } catch (Dali::DaliException e) {
3775       {
3776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3777       };
3778     } catch (...) {
3779       {
3780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3781       };
3782     }
3783   }
3784
3785   jresult = (void *)result;
3786   return jresult;
3787 }
3788
3789
3790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3791   void * jresult ;
3792   Dali::Any *arg1 = (Dali::Any *) 0 ;
3793   Dali::Any *arg2 = 0 ;
3794   Dali::Any *result = 0 ;
3795
3796   arg1 = (Dali::Any *)jarg1;
3797   arg2 = (Dali::Any *)jarg2;
3798   if (!arg2) {
3799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3800     return 0;
3801   }
3802   {
3803     try {
3804       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3805     } catch (std::out_of_range& e) {
3806       {
3807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3808       };
3809     } catch (std::exception& e) {
3810       {
3811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3812       };
3813     } catch (Dali::DaliException e) {
3814       {
3815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3816       };
3817     } catch (...) {
3818       {
3819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3820       };
3821     }
3822   }
3823
3824   jresult = (void *)result;
3825   return jresult;
3826 }
3827
3828
3829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3830   void * jresult ;
3831   Dali::Any *arg1 = (Dali::Any *) 0 ;
3832   std::type_info *result = 0 ;
3833
3834   arg1 = (Dali::Any *)jarg1;
3835   {
3836     try {
3837       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3838     } catch (std::out_of_range& e) {
3839       {
3840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3841       };
3842     } catch (std::exception& e) {
3843       {
3844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3845       };
3846     } catch (Dali::DaliException e) {
3847       {
3848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3849       };
3850     } catch (...) {
3851       {
3852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3853       };
3854     }
3855   }
3856
3857   jresult = (void *)result;
3858   return jresult;
3859 }
3860
3861
3862 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3863   unsigned int jresult ;
3864   Dali::Any *arg1 = (Dali::Any *) 0 ;
3865   bool result;
3866
3867   arg1 = (Dali::Any *)jarg1;
3868   {
3869     try {
3870       result = (bool)((Dali::Any const *)arg1)->Empty();
3871     } catch (std::out_of_range& e) {
3872       {
3873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3874       };
3875     } catch (std::exception& e) {
3876       {
3877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3878       };
3879     } catch (Dali::DaliException e) {
3880       {
3881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3882       };
3883     } catch (...) {
3884       {
3885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3886       };
3887     }
3888   }
3889
3890   jresult = result;
3891   return jresult;
3892 }
3893
3894
3895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3896   void * jresult ;
3897   std::type_info *arg1 = 0 ;
3898   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3899   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3900   Dali::Any::AnyContainerBase *result = 0 ;
3901
3902   arg1 = (std::type_info *)jarg1;
3903   if (!arg1) {
3904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3905     return 0;
3906   }
3907   arg2 = (Dali::Any::CloneFunc)jarg2;
3908   arg3 = (Dali::Any::DeleteFunc)jarg3;
3909   {
3910     try {
3911       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3912     } catch (std::out_of_range& e) {
3913       {
3914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3915       };
3916     } catch (std::exception& e) {
3917       {
3918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3919       };
3920     } catch (Dali::DaliException e) {
3921       {
3922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3923       };
3924     } catch (...) {
3925       {
3926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3927       };
3928     }
3929   }
3930
3931   jresult = (void *)result;
3932   return jresult;
3933 }
3934
3935
3936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3937   void * jresult ;
3938   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3939   std::type_info *result = 0 ;
3940
3941   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3942   {
3943     try {
3944       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3945     } catch (std::out_of_range& e) {
3946       {
3947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3948       };
3949     } catch (std::exception& e) {
3950       {
3951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3952       };
3953     } catch (Dali::DaliException e) {
3954       {
3955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3956       };
3957     } catch (...) {
3958       {
3959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3960       };
3961     }
3962   }
3963
3964   jresult = (void *)result;
3965   return jresult;
3966 }
3967
3968
3969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3970   void * jresult ;
3971   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3972   ::std::type_info *result = 0 ;
3973
3974   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3975   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3976   jresult = (void *)result;
3977   return jresult;
3978 }
3979
3980
3981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3982   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3983   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3984
3985   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3986   arg2 = (Dali::Any::CloneFunc)jarg2;
3987   if (arg1) (arg1)->mCloneFunc = arg2;
3988 }
3989
3990
3991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3992   void * jresult ;
3993   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3994   Dali::Any::CloneFunc result;
3995
3996   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3997   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3998   jresult = (void *)result;
3999   return jresult;
4000 }
4001
4002
4003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
4004   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4005   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
4006
4007   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4008   arg2 = (Dali::Any::DeleteFunc)jarg2;
4009   if (arg1) (arg1)->mDeleteFunc = arg2;
4010 }
4011
4012
4013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
4014   void * jresult ;
4015   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4016   Dali::Any::DeleteFunc result;
4017
4018   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4019   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
4020   jresult = (void *)result;
4021   return jresult;
4022 }
4023
4024
4025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
4026   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4027
4028   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4029   {
4030     try {
4031       delete arg1;
4032     } catch (std::out_of_range& e) {
4033       {
4034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4035       };
4036     } catch (std::exception& e) {
4037       {
4038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4039       };
4040     } catch (Dali::DaliException e) {
4041       {
4042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4043       };
4044     } catch (...) {
4045       {
4046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4047       };
4048     }
4049   }
4050
4051 }
4052
4053
4054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4055   Dali::Any *arg1 = (Dali::Any *) 0 ;
4056   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4057
4058   arg1 = (Dali::Any *)jarg1;
4059   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4060   if (arg1) (arg1)->mContainer = arg2;
4061 }
4062
4063
4064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4065   void * jresult ;
4066   Dali::Any *arg1 = (Dali::Any *) 0 ;
4067   Dali::Any::AnyContainerBase *result = 0 ;
4068
4069   arg1 = (Dali::Any *)jarg1;
4070   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4071   jresult = (void *)result;
4072   return jresult;
4073 }
4074
4075
4076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4077   char *arg1 = (char *) 0 ;
4078   char *arg2 = (char *) 0 ;
4079
4080   arg1 = (char *)jarg1;
4081   arg2 = (char *)jarg2;
4082   {
4083     try {
4084       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4085     } catch (std::out_of_range& e) {
4086       {
4087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4088       };
4089     } catch (std::exception& e) {
4090       {
4091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4092       };
4093     } catch (Dali::DaliException e) {
4094       {
4095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4096       };
4097     } catch (...) {
4098       {
4099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4100       };
4101     }
4102   }
4103
4104 }
4105
4106
4107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4108   void * jresult ;
4109   char *arg1 = (char *) 0 ;
4110   char *arg2 = (char *) 0 ;
4111   Dali::DaliException *result = 0 ;
4112
4113   arg1 = (char *)jarg1;
4114   arg2 = (char *)jarg2;
4115   {
4116     try {
4117       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4118     } catch (std::out_of_range& e) {
4119       {
4120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4121       };
4122     } catch (std::exception& e) {
4123       {
4124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4125       };
4126     } catch (Dali::DaliException e) {
4127       {
4128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4129       };
4130     } catch (...) {
4131       {
4132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4133       };
4134     }
4135   }
4136
4137   jresult = (void *)result;
4138   return jresult;
4139 }
4140
4141
4142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4143   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4144   std::string arg2 = std::string(jarg2);
4145
4146   arg1 = (Dali::DaliException *)jarg1;
4147   {
4148     if (!arg2.empty()) {
4149       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4150     } else {
4151       arg1->location = 0;
4152     }
4153   }
4154 }
4155
4156 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4157   char * jresult ;
4158   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4159   char *result = 0 ;
4160
4161   arg1 = (Dali::DaliException *)jarg1;
4162   result = (char *) ((arg1)->location);
4163   jresult = SWIG_csharp_string_callback((const char *)result);
4164   return jresult;
4165 }
4166
4167
4168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4169   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4170   std::string arg2 = std::string(jarg2);
4171
4172   arg1 = (Dali::DaliException *)jarg1;
4173   {
4174     if (!arg2.empty()) {
4175       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4176     } else {
4177       arg1->condition = 0;
4178     }
4179   }
4180 }
4181
4182
4183 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4184   char * jresult ;
4185   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4186   char *result = 0 ;
4187
4188   arg1 = (Dali::DaliException *)jarg1;
4189   result = (char *) ((arg1)->condition);
4190   jresult = SWIG_csharp_string_callback((const char *)result);
4191   return jresult;
4192 }
4193
4194
4195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4196   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4197
4198   arg1 = (Dali::DaliException *)jarg1;
4199   {
4200     try {
4201       delete arg1;
4202     } catch (std::out_of_range& e) {
4203       {
4204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4205       };
4206     } catch (std::exception& e) {
4207       {
4208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4209       };
4210     } catch (Dali::DaliException e) {
4211       {
4212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4213       };
4214     } catch (...) {
4215       {
4216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4217       };
4218     }
4219   }
4220
4221 }
4222
4223
4224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4225   void * jresult ;
4226   Dali::Vector2 *result = 0 ;
4227
4228   {
4229     try {
4230       result = (Dali::Vector2 *)new Dali::Vector2();
4231     } catch (std::out_of_range& e) {
4232       {
4233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4234       };
4235     } catch (std::exception& e) {
4236       {
4237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4238       };
4239     } catch (Dali::DaliException e) {
4240       {
4241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4242       };
4243     } catch (...) {
4244       {
4245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4246       };
4247     }
4248   }
4249
4250   jresult = (void *)result;
4251   return jresult;
4252 }
4253
4254
4255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4256   void * jresult ;
4257   float arg1 ;
4258   float arg2 ;
4259   Dali::Vector2 *result = 0 ;
4260
4261   arg1 = (float)jarg1;
4262   arg2 = (float)jarg2;
4263   {
4264     try {
4265       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4266     } catch (std::out_of_range& e) {
4267       {
4268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4269       };
4270     } catch (std::exception& e) {
4271       {
4272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4273       };
4274     } catch (Dali::DaliException e) {
4275       {
4276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4277       };
4278     } catch (...) {
4279       {
4280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4281       };
4282     }
4283   }
4284
4285   jresult = (void *)result;
4286   return jresult;
4287 }
4288
4289
4290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4291   void * jresult ;
4292   float *arg1 = (float *) 0 ;
4293   Dali::Vector2 *result = 0 ;
4294
4295   arg1 = jarg1;
4296   {
4297     try {
4298       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4299     } catch (std::out_of_range& e) {
4300       {
4301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4302       };
4303     } catch (std::exception& e) {
4304       {
4305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4306       };
4307     } catch (Dali::DaliException e) {
4308       {
4309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4310       };
4311     } catch (...) {
4312       {
4313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4314       };
4315     }
4316   }
4317
4318   jresult = (void *)result;
4319
4320
4321   return jresult;
4322 }
4323
4324
4325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4326   void * jresult ;
4327   Dali::Vector3 *arg1 = 0 ;
4328   Dali::Vector2 *result = 0 ;
4329
4330   arg1 = (Dali::Vector3 *)jarg1;
4331   if (!arg1) {
4332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4333     return 0;
4334   }
4335   {
4336     try {
4337       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4338     } catch (std::out_of_range& e) {
4339       {
4340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4341       };
4342     } catch (std::exception& e) {
4343       {
4344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4345       };
4346     } catch (Dali::DaliException e) {
4347       {
4348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4349       };
4350     } catch (...) {
4351       {
4352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4353       };
4354     }
4355   }
4356
4357   jresult = (void *)result;
4358   return jresult;
4359 }
4360
4361
4362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4363   void * jresult ;
4364   Dali::Vector4 *arg1 = 0 ;
4365   Dali::Vector2 *result = 0 ;
4366
4367   arg1 = (Dali::Vector4 *)jarg1;
4368   if (!arg1) {
4369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4370     return 0;
4371   }
4372   {
4373     try {
4374       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4375     } catch (std::out_of_range& e) {
4376       {
4377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4378       };
4379     } catch (std::exception& e) {
4380       {
4381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4382       };
4383     } catch (Dali::DaliException e) {
4384       {
4385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4386       };
4387     } catch (...) {
4388       {
4389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4390       };
4391     }
4392   }
4393
4394   jresult = (void *)result;
4395   return jresult;
4396 }
4397
4398
4399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4400   void * jresult ;
4401   Dali::Vector2 *result = 0 ;
4402
4403   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4404   jresult = (void *)result;
4405   return jresult;
4406 }
4407
4408
4409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4410   void * jresult ;
4411   Dali::Vector2 *result = 0 ;
4412
4413   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4414   jresult = (void *)result;
4415   return jresult;
4416 }
4417
4418
4419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4420   void * jresult ;
4421   Dali::Vector2 *result = 0 ;
4422
4423   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4424   jresult = (void *)result;
4425   return jresult;
4426 }
4427
4428
4429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4430   void * jresult ;
4431   Dali::Vector2 *result = 0 ;
4432
4433   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4434   jresult = (void *)result;
4435   return jresult;
4436 }
4437
4438
4439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4440   void * jresult ;
4441   Dali::Vector2 *result = 0 ;
4442
4443   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4444   jresult = (void *)result;
4445   return jresult;
4446 }
4447
4448
4449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4450   void * jresult ;
4451   Dali::Vector2 *result = 0 ;
4452
4453   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4454   jresult = (void *)result;
4455   return jresult;
4456 }
4457
4458
4459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4460   void * jresult ;
4461   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4462   float *arg2 = (float *) 0 ;
4463   Dali::Vector2 *result = 0 ;
4464
4465   arg1 = (Dali::Vector2 *)jarg1;
4466   arg2 = jarg2;
4467   {
4468     try {
4469       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4470     } catch (std::out_of_range& e) {
4471       {
4472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4473       };
4474     } catch (std::exception& e) {
4475       {
4476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4477       };
4478     } catch (Dali::DaliException e) {
4479       {
4480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4481       };
4482     } catch (...) {
4483       {
4484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4485       };
4486     }
4487   }
4488
4489   jresult = (void *)result;
4490
4491
4492   return jresult;
4493 }
4494
4495
4496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4497   void * jresult ;
4498   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4499   Dali::Vector3 *arg2 = 0 ;
4500   Dali::Vector2 *result = 0 ;
4501
4502   arg1 = (Dali::Vector2 *)jarg1;
4503   arg2 = (Dali::Vector3 *)jarg2;
4504   if (!arg2) {
4505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4506     return 0;
4507   }
4508   {
4509     try {
4510       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4511     } catch (std::out_of_range& e) {
4512       {
4513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4514       };
4515     } catch (std::exception& e) {
4516       {
4517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4518       };
4519     } catch (Dali::DaliException e) {
4520       {
4521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4522       };
4523     } catch (...) {
4524       {
4525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4526       };
4527     }
4528   }
4529
4530   jresult = (void *)result;
4531   return jresult;
4532 }
4533
4534
4535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4536   void * jresult ;
4537   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4538   Dali::Vector4 *arg2 = 0 ;
4539   Dali::Vector2 *result = 0 ;
4540
4541   arg1 = (Dali::Vector2 *)jarg1;
4542   arg2 = (Dali::Vector4 *)jarg2;
4543   if (!arg2) {
4544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4545     return 0;
4546   }
4547   {
4548     try {
4549       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4550     } catch (std::out_of_range& e) {
4551       {
4552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4553       };
4554     } catch (std::exception& e) {
4555       {
4556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4557       };
4558     } catch (Dali::DaliException e) {
4559       {
4560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4561       };
4562     } catch (...) {
4563       {
4564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4565       };
4566     }
4567   }
4568
4569   jresult = (void *)result;
4570   return jresult;
4571 }
4572
4573
4574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4575   void * jresult ;
4576   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4577   Dali::Vector2 *arg2 = 0 ;
4578   Dali::Vector2 result;
4579
4580   arg1 = (Dali::Vector2 *)jarg1;
4581   arg2 = (Dali::Vector2 *)jarg2;
4582   if (!arg2) {
4583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4584     return 0;
4585   }
4586   {
4587     try {
4588       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4589     } catch (std::out_of_range& e) {
4590       {
4591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4592       };
4593     } catch (std::exception& e) {
4594       {
4595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4596       };
4597     } catch (Dali::DaliException e) {
4598       {
4599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4600       };
4601     } catch (...) {
4602       {
4603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4604       };
4605     }
4606   }
4607
4608   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4609   return jresult;
4610 }
4611
4612
4613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4614   void * jresult ;
4615   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4616   Dali::Vector2 *arg2 = 0 ;
4617   Dali::Vector2 *result = 0 ;
4618
4619   arg1 = (Dali::Vector2 *)jarg1;
4620   arg2 = (Dali::Vector2 *)jarg2;
4621   if (!arg2) {
4622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4623     return 0;
4624   }
4625   {
4626     try {
4627       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4628     } catch (std::out_of_range& e) {
4629       {
4630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4631       };
4632     } catch (std::exception& e) {
4633       {
4634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4635       };
4636     } catch (Dali::DaliException e) {
4637       {
4638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4639       };
4640     } catch (...) {
4641       {
4642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4643       };
4644     }
4645   }
4646
4647   jresult = (void *)result;
4648   return jresult;
4649 }
4650
4651
4652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4653   void * jresult ;
4654   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4655   Dali::Vector2 *arg2 = 0 ;
4656   Dali::Vector2 result;
4657
4658   arg1 = (Dali::Vector2 *)jarg1;
4659   arg2 = (Dali::Vector2 *)jarg2;
4660   if (!arg2) {
4661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4662     return 0;
4663   }
4664   {
4665     try {
4666       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4667     } catch (std::out_of_range& e) {
4668       {
4669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4670       };
4671     } catch (std::exception& e) {
4672       {
4673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4674       };
4675     } catch (Dali::DaliException e) {
4676       {
4677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4678       };
4679     } catch (...) {
4680       {
4681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4682       };
4683     }
4684   }
4685
4686   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4687   return jresult;
4688 }
4689
4690
4691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4692   void * jresult ;
4693   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4694   Dali::Vector2 *arg2 = 0 ;
4695   Dali::Vector2 *result = 0 ;
4696
4697   arg1 = (Dali::Vector2 *)jarg1;
4698   arg2 = (Dali::Vector2 *)jarg2;
4699   if (!arg2) {
4700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4701     return 0;
4702   }
4703   {
4704     try {
4705       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4706     } catch (std::out_of_range& e) {
4707       {
4708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4709       };
4710     } catch (std::exception& e) {
4711       {
4712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4713       };
4714     } catch (Dali::DaliException e) {
4715       {
4716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4717       };
4718     } catch (...) {
4719       {
4720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4721       };
4722     }
4723   }
4724
4725   jresult = (void *)result;
4726   return jresult;
4727 }
4728
4729
4730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4731   void * jresult ;
4732   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4733   Dali::Vector2 *arg2 = 0 ;
4734   Dali::Vector2 result;
4735
4736   arg1 = (Dali::Vector2 *)jarg1;
4737   arg2 = (Dali::Vector2 *)jarg2;
4738   if (!arg2) {
4739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4740     return 0;
4741   }
4742   {
4743     try {
4744       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4745     } catch (std::out_of_range& e) {
4746       {
4747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4748       };
4749     } catch (std::exception& e) {
4750       {
4751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4752       };
4753     } catch (Dali::DaliException e) {
4754       {
4755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4756       };
4757     } catch (...) {
4758       {
4759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4760       };
4761     }
4762   }
4763
4764   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4765   return jresult;
4766 }
4767
4768
4769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4770   void * jresult ;
4771   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4772   float arg2 ;
4773   Dali::Vector2 result;
4774
4775   arg1 = (Dali::Vector2 *)jarg1;
4776   arg2 = (float)jarg2;
4777   {
4778     try {
4779       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4780     } catch (std::out_of_range& e) {
4781       {
4782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4783       };
4784     } catch (std::exception& e) {
4785       {
4786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4787       };
4788     } catch (Dali::DaliException e) {
4789       {
4790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4791       };
4792     } catch (...) {
4793       {
4794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4795       };
4796     }
4797   }
4798
4799   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4800   return jresult;
4801 }
4802
4803
4804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4805   void * jresult ;
4806   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4807   Dali::Vector2 *arg2 = 0 ;
4808   Dali::Vector2 *result = 0 ;
4809
4810   arg1 = (Dali::Vector2 *)jarg1;
4811   arg2 = (Dali::Vector2 *)jarg2;
4812   if (!arg2) {
4813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4814     return 0;
4815   }
4816   {
4817     try {
4818       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4819     } catch (std::out_of_range& e) {
4820       {
4821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4822       };
4823     } catch (std::exception& e) {
4824       {
4825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4826       };
4827     } catch (Dali::DaliException e) {
4828       {
4829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4830       };
4831     } catch (...) {
4832       {
4833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4834       };
4835     }
4836   }
4837
4838   jresult = (void *)result;
4839   return jresult;
4840 }
4841
4842
4843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4844   void * jresult ;
4845   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4846   float arg2 ;
4847   Dali::Vector2 *result = 0 ;
4848
4849   arg1 = (Dali::Vector2 *)jarg1;
4850   arg2 = (float)jarg2;
4851   {
4852     try {
4853       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4854     } catch (std::out_of_range& e) {
4855       {
4856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4857       };
4858     } catch (std::exception& e) {
4859       {
4860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4861       };
4862     } catch (Dali::DaliException e) {
4863       {
4864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4865       };
4866     } catch (...) {
4867       {
4868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4869       };
4870     }
4871   }
4872
4873   jresult = (void *)result;
4874   return jresult;
4875 }
4876
4877
4878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4879   void * jresult ;
4880   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4881   Dali::Vector2 *arg2 = 0 ;
4882   Dali::Vector2 result;
4883
4884   arg1 = (Dali::Vector2 *)jarg1;
4885   arg2 = (Dali::Vector2 *)jarg2;
4886   if (!arg2) {
4887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4888     return 0;
4889   }
4890   {
4891     try {
4892       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4893     } catch (std::out_of_range& e) {
4894       {
4895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4896       };
4897     } catch (std::exception& e) {
4898       {
4899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4900       };
4901     } catch (Dali::DaliException e) {
4902       {
4903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4904       };
4905     } catch (...) {
4906       {
4907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4908       };
4909     }
4910   }
4911
4912   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4913   return jresult;
4914 }
4915
4916
4917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4918   void * jresult ;
4919   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4920   float arg2 ;
4921   Dali::Vector2 result;
4922
4923   arg1 = (Dali::Vector2 *)jarg1;
4924   arg2 = (float)jarg2;
4925   {
4926     try {
4927       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4928     } catch (std::out_of_range& e) {
4929       {
4930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4931       };
4932     } catch (std::exception& e) {
4933       {
4934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4935       };
4936     } catch (Dali::DaliException e) {
4937       {
4938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4939       };
4940     } catch (...) {
4941       {
4942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4943       };
4944     }
4945   }
4946
4947   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4948   return jresult;
4949 }
4950
4951
4952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4953   void * jresult ;
4954   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4955   Dali::Vector2 *arg2 = 0 ;
4956   Dali::Vector2 *result = 0 ;
4957
4958   arg1 = (Dali::Vector2 *)jarg1;
4959   arg2 = (Dali::Vector2 *)jarg2;
4960   if (!arg2) {
4961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4962     return 0;
4963   }
4964   {
4965     try {
4966       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4967     } catch (std::out_of_range& e) {
4968       {
4969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4970       };
4971     } catch (std::exception& e) {
4972       {
4973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4974       };
4975     } catch (Dali::DaliException e) {
4976       {
4977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4978       };
4979     } catch (...) {
4980       {
4981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4982       };
4983     }
4984   }
4985
4986   jresult = (void *)result;
4987   return jresult;
4988 }
4989
4990
4991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4992   void * jresult ;
4993   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4994   float arg2 ;
4995   Dali::Vector2 *result = 0 ;
4996
4997   arg1 = (Dali::Vector2 *)jarg1;
4998   arg2 = (float)jarg2;
4999   {
5000     try {
5001       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
5002     } catch (std::out_of_range& e) {
5003       {
5004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5005       };
5006     } catch (std::exception& e) {
5007       {
5008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5009       };
5010     } catch (Dali::DaliException e) {
5011       {
5012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5013       };
5014     } catch (...) {
5015       {
5016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5017       };
5018     }
5019   }
5020
5021   jresult = (void *)result;
5022   return jresult;
5023 }
5024
5025
5026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
5027   void * jresult ;
5028   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5029   Dali::Vector2 result;
5030
5031   arg1 = (Dali::Vector2 *)jarg1;
5032   {
5033     try {
5034       result = ((Dali::Vector2 const *)arg1)->operator -();
5035     } catch (std::out_of_range& e) {
5036       {
5037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5038       };
5039     } catch (std::exception& e) {
5040       {
5041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5042       };
5043     } catch (Dali::DaliException e) {
5044       {
5045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5046       };
5047     } catch (...) {
5048       {
5049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5050       };
5051     }
5052   }
5053
5054   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5055   return jresult;
5056 }
5057
5058
5059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5060   unsigned int jresult ;
5061   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5062   Dali::Vector2 *arg2 = 0 ;
5063   bool result;
5064
5065   arg1 = (Dali::Vector2 *)jarg1;
5066   arg2 = (Dali::Vector2 *)jarg2;
5067   if (!arg2) {
5068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5069     return 0;
5070   }
5071   {
5072     try {
5073       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5074     } catch (std::out_of_range& e) {
5075       {
5076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5077       };
5078     } catch (std::exception& e) {
5079       {
5080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5081       };
5082     } catch (Dali::DaliException e) {
5083       {
5084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5085       };
5086     } catch (...) {
5087       {
5088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5089       };
5090     }
5091   }
5092
5093   jresult = result;
5094   return jresult;
5095 }
5096
5097
5098 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5099   unsigned int jresult ;
5100   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5101   Dali::Vector2 *arg2 = 0 ;
5102   bool result;
5103
5104   arg1 = (Dali::Vector2 *)jarg1;
5105   arg2 = (Dali::Vector2 *)jarg2;
5106   if (!arg2) {
5107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5108     return 0;
5109   }
5110   {
5111     try {
5112       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5113     } catch (std::out_of_range& e) {
5114       {
5115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5116       };
5117     } catch (std::exception& e) {
5118       {
5119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5120       };
5121     } catch (Dali::DaliException e) {
5122       {
5123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5124       };
5125     } catch (...) {
5126       {
5127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5128       };
5129     }
5130   }
5131
5132   jresult = result;
5133   return jresult;
5134 }
5135
5136
5137 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5138   float jresult ;
5139   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5140   unsigned int arg2 ;
5141   float *result = 0 ;
5142
5143   arg1 = (Dali::Vector2 *)jarg1;
5144   arg2 = (unsigned int)jarg2;
5145   {
5146     try {
5147       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5148     } catch (std::out_of_range& e) {
5149       {
5150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5151       };
5152     } catch (std::exception& e) {
5153       {
5154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5155       };
5156     } catch (Dali::DaliException e) {
5157       {
5158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5159       };
5160     } catch (...) {
5161       {
5162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5163       };
5164     }
5165   }
5166
5167   jresult = *result;
5168   return jresult;
5169 }
5170
5171
5172 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5173   float jresult ;
5174   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5175   float result;
5176
5177   arg1 = (Dali::Vector2 *)jarg1;
5178   {
5179     try {
5180       result = (float)((Dali::Vector2 const *)arg1)->Length();
5181     } catch (std::out_of_range& e) {
5182       {
5183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5184       };
5185     } catch (std::exception& e) {
5186       {
5187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5188       };
5189     } catch (Dali::DaliException e) {
5190       {
5191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5192       };
5193     } catch (...) {
5194       {
5195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5196       };
5197     }
5198   }
5199
5200   jresult = result;
5201   return jresult;
5202 }
5203
5204
5205 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5206   float jresult ;
5207   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5208   float result;
5209
5210   arg1 = (Dali::Vector2 *)jarg1;
5211   {
5212     try {
5213       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5214     } catch (std::out_of_range& e) {
5215       {
5216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5217       };
5218     } catch (std::exception& e) {
5219       {
5220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5221       };
5222     } catch (Dali::DaliException e) {
5223       {
5224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5225       };
5226     } catch (...) {
5227       {
5228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5229       };
5230     }
5231   }
5232
5233   jresult = result;
5234   return jresult;
5235 }
5236
5237
5238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5239   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5240
5241   arg1 = (Dali::Vector2 *)jarg1;
5242   {
5243     try {
5244       (arg1)->Normalize();
5245     } catch (std::out_of_range& e) {
5246       {
5247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5248       };
5249     } catch (std::exception& e) {
5250       {
5251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5252       };
5253     } catch (Dali::DaliException e) {
5254       {
5255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5256       };
5257     } catch (...) {
5258       {
5259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5260       };
5261     }
5262   }
5263
5264 }
5265
5266
5267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5268   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5269   Dali::Vector2 *arg2 = 0 ;
5270   Dali::Vector2 *arg3 = 0 ;
5271
5272   arg1 = (Dali::Vector2 *)jarg1;
5273   arg2 = (Dali::Vector2 *)jarg2;
5274   if (!arg2) {
5275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5276     return ;
5277   }
5278   arg3 = (Dali::Vector2 *)jarg3;
5279   if (!arg3) {
5280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5281     return ;
5282   }
5283   {
5284     try {
5285       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5286     } catch (std::out_of_range& e) {
5287       {
5288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5289       };
5290     } catch (std::exception& e) {
5291       {
5292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5293       };
5294     } catch (Dali::DaliException e) {
5295       {
5296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5297       };
5298     } catch (...) {
5299       {
5300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5301       };
5302     }
5303   }
5304
5305 }
5306
5307
5308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5309   void * jresult ;
5310   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5311   float *result = 0 ;
5312
5313   arg1 = (Dali::Vector2 *)jarg1;
5314   {
5315     try {
5316       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5317     } catch (std::out_of_range& e) {
5318       {
5319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5320       };
5321     } catch (std::exception& e) {
5322       {
5323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5324       };
5325     } catch (Dali::DaliException e) {
5326       {
5327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5328       };
5329     } catch (...) {
5330       {
5331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5332       };
5333     }
5334   }
5335
5336   jresult = (void *)result;
5337   return jresult;
5338 }
5339
5340
5341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5342   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5343   float arg2 ;
5344
5345   arg1 = (Dali::Vector2 *)jarg1;
5346   arg2 = (float)jarg2;
5347   if (arg1) (arg1)->x = arg2;
5348 }
5349
5350
5351 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5352   float jresult ;
5353   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5354   float result;
5355
5356   arg1 = (Dali::Vector2 *)jarg1;
5357   result = (float) ((arg1)->x);
5358   jresult = result;
5359   return jresult;
5360 }
5361
5362
5363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5364   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5365   float arg2 ;
5366
5367   arg1 = (Dali::Vector2 *)jarg1;
5368   arg2 = (float)jarg2;
5369   if (arg1) (arg1)->width = arg2;
5370 }
5371
5372
5373 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5374   float jresult ;
5375   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5376   float result;
5377
5378   arg1 = (Dali::Vector2 *)jarg1;
5379   result = (float) ((arg1)->width);
5380   jresult = result;
5381   return jresult;
5382 }
5383
5384
5385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5386   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5387   float arg2 ;
5388
5389   arg1 = (Dali::Vector2 *)jarg1;
5390   arg2 = (float)jarg2;
5391   if (arg1) (arg1)->y = arg2;
5392 }
5393
5394
5395 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5396   float jresult ;
5397   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5398   float result;
5399
5400   arg1 = (Dali::Vector2 *)jarg1;
5401   result = (float) ((arg1)->y);
5402   jresult = result;
5403   return jresult;
5404 }
5405
5406
5407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5408   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5409   float arg2 ;
5410
5411   arg1 = (Dali::Vector2 *)jarg1;
5412   arg2 = (float)jarg2;
5413   if (arg1) (arg1)->height = arg2;
5414 }
5415
5416
5417 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5418   float jresult ;
5419   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5420   float result;
5421
5422   arg1 = (Dali::Vector2 *)jarg1;
5423   result = (float) ((arg1)->height);
5424   jresult = result;
5425   return jresult;
5426 }
5427
5428
5429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5430   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5431
5432   arg1 = (Dali::Vector2 *)jarg1;
5433   {
5434     try {
5435       delete arg1;
5436     } catch (std::out_of_range& e) {
5437       {
5438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5439       };
5440     } catch (std::exception& e) {
5441       {
5442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5443       };
5444     } catch (Dali::DaliException e) {
5445       {
5446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5447       };
5448     } catch (...) {
5449       {
5450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5451       };
5452     }
5453   }
5454
5455 }
5456
5457
5458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5459   void * jresult ;
5460   Dali::Vector2 *arg1 = 0 ;
5461   Dali::Vector2 *arg2 = 0 ;
5462   Dali::Vector2 result;
5463
5464   arg1 = (Dali::Vector2 *)jarg1;
5465   if (!arg1) {
5466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5467     return 0;
5468   }
5469   arg2 = (Dali::Vector2 *)jarg2;
5470   if (!arg2) {
5471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5472     return 0;
5473   }
5474   {
5475     try {
5476       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5477     } catch (std::out_of_range& e) {
5478       {
5479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5480       };
5481     } catch (std::exception& e) {
5482       {
5483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5484       };
5485     } catch (Dali::DaliException e) {
5486       {
5487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5488       };
5489     } catch (...) {
5490       {
5491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5492       };
5493     }
5494   }
5495
5496   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5497   return jresult;
5498 }
5499
5500
5501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5502   void * jresult ;
5503   Dali::Vector2 *arg1 = 0 ;
5504   Dali::Vector2 *arg2 = 0 ;
5505   Dali::Vector2 result;
5506
5507   arg1 = (Dali::Vector2 *)jarg1;
5508   if (!arg1) {
5509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5510     return 0;
5511   }
5512   arg2 = (Dali::Vector2 *)jarg2;
5513   if (!arg2) {
5514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5515     return 0;
5516   }
5517   {
5518     try {
5519       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5520     } catch (std::out_of_range& e) {
5521       {
5522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5523       };
5524     } catch (std::exception& e) {
5525       {
5526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5527       };
5528     } catch (Dali::DaliException e) {
5529       {
5530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5531       };
5532     } catch (...) {
5533       {
5534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5535       };
5536     }
5537   }
5538
5539   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5540   return jresult;
5541 }
5542
5543
5544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5545   void * jresult ;
5546   Dali::Vector2 *arg1 = 0 ;
5547   float *arg2 = 0 ;
5548   float *arg3 = 0 ;
5549   float temp2 ;
5550   float temp3 ;
5551   Dali::Vector2 result;
5552
5553   arg1 = (Dali::Vector2 *)jarg1;
5554   if (!arg1) {
5555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5556     return 0;
5557   }
5558   temp2 = (float)jarg2;
5559   arg2 = &temp2;
5560   temp3 = (float)jarg3;
5561   arg3 = &temp3;
5562   {
5563     try {
5564       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5565     } catch (std::out_of_range& e) {
5566       {
5567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5568       };
5569     } catch (std::exception& e) {
5570       {
5571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5572       };
5573     } catch (Dali::DaliException e) {
5574       {
5575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5576       };
5577     } catch (...) {
5578       {
5579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5580       };
5581     }
5582   }
5583
5584   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5585   return jresult;
5586 }
5587
5588
5589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5590   void * jresult ;
5591   Dali::Vector3 *result = 0 ;
5592
5593   {
5594     try {
5595       result = (Dali::Vector3 *)new Dali::Vector3();
5596     } catch (std::out_of_range& e) {
5597       {
5598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5599       };
5600     } catch (std::exception& e) {
5601       {
5602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5603       };
5604     } catch (Dali::DaliException e) {
5605       {
5606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5607       };
5608     } catch (...) {
5609       {
5610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5611       };
5612     }
5613   }
5614
5615   jresult = (void *)result;
5616   return jresult;
5617 }
5618
5619
5620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5621   void * jresult ;
5622   float arg1 ;
5623   float arg2 ;
5624   float arg3 ;
5625   Dali::Vector3 *result = 0 ;
5626
5627   arg1 = (float)jarg1;
5628   arg2 = (float)jarg2;
5629   arg3 = (float)jarg3;
5630   {
5631     try {
5632       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5633     } catch (std::out_of_range& e) {
5634       {
5635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5636       };
5637     } catch (std::exception& e) {
5638       {
5639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5640       };
5641     } catch (Dali::DaliException e) {
5642       {
5643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5644       };
5645     } catch (...) {
5646       {
5647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5648       };
5649     }
5650   }
5651
5652   jresult = (void *)result;
5653   return jresult;
5654 }
5655
5656
5657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5658   void * jresult ;
5659   float *arg1 = (float *) 0 ;
5660   Dali::Vector3 *result = 0 ;
5661
5662   arg1 = jarg1;
5663   {
5664     try {
5665       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5666     } catch (std::out_of_range& e) {
5667       {
5668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5669       };
5670     } catch (std::exception& e) {
5671       {
5672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5673       };
5674     } catch (Dali::DaliException e) {
5675       {
5676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5677       };
5678     } catch (...) {
5679       {
5680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5681       };
5682     }
5683   }
5684
5685   jresult = (void *)result;
5686
5687
5688   return jresult;
5689 }
5690
5691
5692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5693   void * jresult ;
5694   Dali::Vector2 *arg1 = 0 ;
5695   Dali::Vector3 *result = 0 ;
5696
5697   arg1 = (Dali::Vector2 *)jarg1;
5698   if (!arg1) {
5699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5700     return 0;
5701   }
5702   {
5703     try {
5704       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5705     } catch (std::out_of_range& e) {
5706       {
5707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5708       };
5709     } catch (std::exception& e) {
5710       {
5711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5712       };
5713     } catch (Dali::DaliException e) {
5714       {
5715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5716       };
5717     } catch (...) {
5718       {
5719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5720       };
5721     }
5722   }
5723
5724   jresult = (void *)result;
5725   return jresult;
5726 }
5727
5728
5729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5730   void * jresult ;
5731   Dali::Vector4 *arg1 = 0 ;
5732   Dali::Vector3 *result = 0 ;
5733
5734   arg1 = (Dali::Vector4 *)jarg1;
5735   if (!arg1) {
5736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5737     return 0;
5738   }
5739   {
5740     try {
5741       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5742     } catch (std::out_of_range& e) {
5743       {
5744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5745       };
5746     } catch (std::exception& e) {
5747       {
5748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5749       };
5750     } catch (Dali::DaliException e) {
5751       {
5752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5753       };
5754     } catch (...) {
5755       {
5756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5757       };
5758     }
5759   }
5760
5761   jresult = (void *)result;
5762   return jresult;
5763 }
5764
5765
5766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5767   void * jresult ;
5768   Dali::Vector3 *result = 0 ;
5769
5770   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5771   jresult = (void *)result;
5772   return jresult;
5773 }
5774
5775
5776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5777   void * jresult ;
5778   Dali::Vector3 *result = 0 ;
5779
5780   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5781   jresult = (void *)result;
5782   return jresult;
5783 }
5784
5785
5786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5787   void * jresult ;
5788   Dali::Vector3 *result = 0 ;
5789
5790   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5791   jresult = (void *)result;
5792   return jresult;
5793 }
5794
5795
5796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5797   void * jresult ;
5798   Dali::Vector3 *result = 0 ;
5799
5800   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5801   jresult = (void *)result;
5802   return jresult;
5803 }
5804
5805
5806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5807   void * jresult ;
5808   Dali::Vector3 *result = 0 ;
5809
5810   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5811   jresult = (void *)result;
5812   return jresult;
5813 }
5814
5815
5816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5817   void * jresult ;
5818   Dali::Vector3 *result = 0 ;
5819
5820   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5821   jresult = (void *)result;
5822   return jresult;
5823 }
5824
5825
5826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5827   void * jresult ;
5828   Dali::Vector3 *result = 0 ;
5829
5830   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5831   jresult = (void *)result;
5832   return jresult;
5833 }
5834
5835
5836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5837   void * jresult ;
5838   Dali::Vector3 *result = 0 ;
5839
5840   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5841   jresult = (void *)result;
5842   return jresult;
5843 }
5844
5845
5846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5847   void * jresult ;
5848   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5849   float *arg2 = (float *) 0 ;
5850   Dali::Vector3 *result = 0 ;
5851
5852   arg1 = (Dali::Vector3 *)jarg1;
5853   arg2 = jarg2;
5854   {
5855     try {
5856       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5857     } catch (std::out_of_range& e) {
5858       {
5859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5860       };
5861     } catch (std::exception& e) {
5862       {
5863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5864       };
5865     } catch (Dali::DaliException e) {
5866       {
5867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5868       };
5869     } catch (...) {
5870       {
5871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5872       };
5873     }
5874   }
5875
5876   jresult = (void *)result;
5877
5878
5879   return jresult;
5880 }
5881
5882
5883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5884   void * jresult ;
5885   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5886   Dali::Vector2 *arg2 = 0 ;
5887   Dali::Vector3 *result = 0 ;
5888
5889   arg1 = (Dali::Vector3 *)jarg1;
5890   arg2 = (Dali::Vector2 *)jarg2;
5891   if (!arg2) {
5892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5893     return 0;
5894   }
5895   {
5896     try {
5897       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5898     } catch (std::out_of_range& e) {
5899       {
5900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5901       };
5902     } catch (std::exception& e) {
5903       {
5904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5905       };
5906     } catch (Dali::DaliException e) {
5907       {
5908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5909       };
5910     } catch (...) {
5911       {
5912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5913       };
5914     }
5915   }
5916
5917   jresult = (void *)result;
5918   return jresult;
5919 }
5920
5921
5922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5923   void * jresult ;
5924   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5925   Dali::Vector4 *arg2 = 0 ;
5926   Dali::Vector3 *result = 0 ;
5927
5928   arg1 = (Dali::Vector3 *)jarg1;
5929   arg2 = (Dali::Vector4 *)jarg2;
5930   if (!arg2) {
5931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5932     return 0;
5933   }
5934   {
5935     try {
5936       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5937     } catch (std::out_of_range& e) {
5938       {
5939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5940       };
5941     } catch (std::exception& e) {
5942       {
5943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5944       };
5945     } catch (Dali::DaliException e) {
5946       {
5947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5948       };
5949     } catch (...) {
5950       {
5951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5952       };
5953     }
5954   }
5955
5956   jresult = (void *)result;
5957   return jresult;
5958 }
5959
5960
5961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5962   void * jresult ;
5963   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5964   Dali::Vector3 *arg2 = 0 ;
5965   Dali::Vector3 result;
5966
5967   arg1 = (Dali::Vector3 *)jarg1;
5968   arg2 = (Dali::Vector3 *)jarg2;
5969   if (!arg2) {
5970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5971     return 0;
5972   }
5973   {
5974     try {
5975       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5976     } catch (std::out_of_range& e) {
5977       {
5978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5979       };
5980     } catch (std::exception& e) {
5981       {
5982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5983       };
5984     } catch (Dali::DaliException e) {
5985       {
5986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5987       };
5988     } catch (...) {
5989       {
5990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5991       };
5992     }
5993   }
5994
5995   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5996   return jresult;
5997 }
5998
5999
6000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
6001   void * jresult ;
6002   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6003   Dali::Vector3 *arg2 = 0 ;
6004   Dali::Vector3 *result = 0 ;
6005
6006   arg1 = (Dali::Vector3 *)jarg1;
6007   arg2 = (Dali::Vector3 *)jarg2;
6008   if (!arg2) {
6009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6010     return 0;
6011   }
6012   {
6013     try {
6014       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
6015     } catch (std::out_of_range& e) {
6016       {
6017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6018       };
6019     } catch (std::exception& e) {
6020       {
6021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6022       };
6023     } catch (Dali::DaliException e) {
6024       {
6025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6026       };
6027     } catch (...) {
6028       {
6029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6030       };
6031     }
6032   }
6033
6034   jresult = (void *)result;
6035   return jresult;
6036 }
6037
6038
6039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6040   void * jresult ;
6041   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6042   Dali::Vector3 *arg2 = 0 ;
6043   Dali::Vector3 result;
6044
6045   arg1 = (Dali::Vector3 *)jarg1;
6046   arg2 = (Dali::Vector3 *)jarg2;
6047   if (!arg2) {
6048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6049     return 0;
6050   }
6051   {
6052     try {
6053       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6054     } catch (std::out_of_range& e) {
6055       {
6056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6057       };
6058     } catch (std::exception& e) {
6059       {
6060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6061       };
6062     } catch (Dali::DaliException e) {
6063       {
6064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6065       };
6066     } catch (...) {
6067       {
6068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6069       };
6070     }
6071   }
6072
6073   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6074   return jresult;
6075 }
6076
6077
6078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6079   void * jresult ;
6080   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6081   Dali::Vector3 *arg2 = 0 ;
6082   Dali::Vector3 *result = 0 ;
6083
6084   arg1 = (Dali::Vector3 *)jarg1;
6085   arg2 = (Dali::Vector3 *)jarg2;
6086   if (!arg2) {
6087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6088     return 0;
6089   }
6090   {
6091     try {
6092       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6093     } catch (std::out_of_range& e) {
6094       {
6095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6096       };
6097     } catch (std::exception& e) {
6098       {
6099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6100       };
6101     } catch (Dali::DaliException e) {
6102       {
6103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6104       };
6105     } catch (...) {
6106       {
6107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6108       };
6109     }
6110   }
6111
6112   jresult = (void *)result;
6113   return jresult;
6114 }
6115
6116
6117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6118   void * jresult ;
6119   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6120   Dali::Vector3 *arg2 = 0 ;
6121   Dali::Vector3 result;
6122
6123   arg1 = (Dali::Vector3 *)jarg1;
6124   arg2 = (Dali::Vector3 *)jarg2;
6125   if (!arg2) {
6126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6127     return 0;
6128   }
6129   {
6130     try {
6131       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6132     } catch (std::out_of_range& e) {
6133       {
6134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6135       };
6136     } catch (std::exception& e) {
6137       {
6138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6139       };
6140     } catch (Dali::DaliException e) {
6141       {
6142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6143       };
6144     } catch (...) {
6145       {
6146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6147       };
6148     }
6149   }
6150
6151   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6152   return jresult;
6153 }
6154
6155
6156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6157   void * jresult ;
6158   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6159   float arg2 ;
6160   Dali::Vector3 result;
6161
6162   arg1 = (Dali::Vector3 *)jarg1;
6163   arg2 = (float)jarg2;
6164   {
6165     try {
6166       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6167     } catch (std::out_of_range& e) {
6168       {
6169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6170       };
6171     } catch (std::exception& e) {
6172       {
6173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6174       };
6175     } catch (Dali::DaliException e) {
6176       {
6177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6178       };
6179     } catch (...) {
6180       {
6181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6182       };
6183     }
6184   }
6185
6186   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6187   return jresult;
6188 }
6189
6190
6191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6192   void * jresult ;
6193   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6194   Dali::Vector3 *arg2 = 0 ;
6195   Dali::Vector3 *result = 0 ;
6196
6197   arg1 = (Dali::Vector3 *)jarg1;
6198   arg2 = (Dali::Vector3 *)jarg2;
6199   if (!arg2) {
6200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6201     return 0;
6202   }
6203   {
6204     try {
6205       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6206     } catch (std::out_of_range& e) {
6207       {
6208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6209       };
6210     } catch (std::exception& e) {
6211       {
6212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6213       };
6214     } catch (Dali::DaliException e) {
6215       {
6216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6217       };
6218     } catch (...) {
6219       {
6220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6221       };
6222     }
6223   }
6224
6225   jresult = (void *)result;
6226   return jresult;
6227 }
6228
6229
6230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6231   void * jresult ;
6232   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6233   float arg2 ;
6234   Dali::Vector3 *result = 0 ;
6235
6236   arg1 = (Dali::Vector3 *)jarg1;
6237   arg2 = (float)jarg2;
6238   {
6239     try {
6240       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6241     } catch (std::out_of_range& e) {
6242       {
6243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6244       };
6245     } catch (std::exception& e) {
6246       {
6247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6248       };
6249     } catch (Dali::DaliException e) {
6250       {
6251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6252       };
6253     } catch (...) {
6254       {
6255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6256       };
6257     }
6258   }
6259
6260   jresult = (void *)result;
6261   return jresult;
6262 }
6263
6264
6265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6266   void * jresult ;
6267   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6268   Dali::Quaternion *arg2 = 0 ;
6269   Dali::Vector3 *result = 0 ;
6270
6271   arg1 = (Dali::Vector3 *)jarg1;
6272   arg2 = (Dali::Quaternion *)jarg2;
6273   if (!arg2) {
6274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6275     return 0;
6276   }
6277   {
6278     try {
6279       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6280     } catch (std::out_of_range& e) {
6281       {
6282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6283       };
6284     } catch (std::exception& e) {
6285       {
6286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6287       };
6288     } catch (Dali::DaliException e) {
6289       {
6290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6291       };
6292     } catch (...) {
6293       {
6294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6295       };
6296     }
6297   }
6298
6299   jresult = (void *)result;
6300   return jresult;
6301 }
6302
6303
6304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6305   void * jresult ;
6306   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6307   Dali::Vector3 *arg2 = 0 ;
6308   Dali::Vector3 result;
6309
6310   arg1 = (Dali::Vector3 *)jarg1;
6311   arg2 = (Dali::Vector3 *)jarg2;
6312   if (!arg2) {
6313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6314     return 0;
6315   }
6316   {
6317     try {
6318       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6319     } catch (std::out_of_range& e) {
6320       {
6321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6322       };
6323     } catch (std::exception& e) {
6324       {
6325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6326       };
6327     } catch (Dali::DaliException e) {
6328       {
6329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6330       };
6331     } catch (...) {
6332       {
6333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6334       };
6335     }
6336   }
6337
6338   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6339   return jresult;
6340 }
6341
6342
6343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6344   void * jresult ;
6345   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6346   float arg2 ;
6347   Dali::Vector3 result;
6348
6349   arg1 = (Dali::Vector3 *)jarg1;
6350   arg2 = (float)jarg2;
6351   {
6352     try {
6353       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6354     } catch (std::out_of_range& e) {
6355       {
6356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6357       };
6358     } catch (std::exception& e) {
6359       {
6360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6361       };
6362     } catch (Dali::DaliException e) {
6363       {
6364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6365       };
6366     } catch (...) {
6367       {
6368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6369       };
6370     }
6371   }
6372
6373   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6374   return jresult;
6375 }
6376
6377
6378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6379   void * jresult ;
6380   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6381   Dali::Vector3 *arg2 = 0 ;
6382   Dali::Vector3 *result = 0 ;
6383
6384   arg1 = (Dali::Vector3 *)jarg1;
6385   arg2 = (Dali::Vector3 *)jarg2;
6386   if (!arg2) {
6387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6388     return 0;
6389   }
6390   {
6391     try {
6392       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6393     } catch (std::out_of_range& e) {
6394       {
6395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6396       };
6397     } catch (std::exception& e) {
6398       {
6399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6400       };
6401     } catch (Dali::DaliException e) {
6402       {
6403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6404       };
6405     } catch (...) {
6406       {
6407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6408       };
6409     }
6410   }
6411
6412   jresult = (void *)result;
6413   return jresult;
6414 }
6415
6416
6417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6418   void * jresult ;
6419   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6420   float arg2 ;
6421   Dali::Vector3 *result = 0 ;
6422
6423   arg1 = (Dali::Vector3 *)jarg1;
6424   arg2 = (float)jarg2;
6425   {
6426     try {
6427       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6428     } catch (std::out_of_range& e) {
6429       {
6430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6431       };
6432     } catch (std::exception& e) {
6433       {
6434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6435       };
6436     } catch (Dali::DaliException e) {
6437       {
6438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6439       };
6440     } catch (...) {
6441       {
6442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6443       };
6444     }
6445   }
6446
6447   jresult = (void *)result;
6448   return jresult;
6449 }
6450
6451
6452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6453   void * jresult ;
6454   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6455   Dali::Vector3 result;
6456
6457   arg1 = (Dali::Vector3 *)jarg1;
6458   {
6459     try {
6460       result = ((Dali::Vector3 const *)arg1)->operator -();
6461     } catch (std::out_of_range& e) {
6462       {
6463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6464       };
6465     } catch (std::exception& e) {
6466       {
6467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6468       };
6469     } catch (Dali::DaliException e) {
6470       {
6471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6472       };
6473     } catch (...) {
6474       {
6475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6476       };
6477     }
6478   }
6479
6480   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6481   return jresult;
6482 }
6483
6484
6485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6486   unsigned int jresult ;
6487   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6488   Dali::Vector3 *arg2 = 0 ;
6489   bool result;
6490
6491   arg1 = (Dali::Vector3 *)jarg1;
6492   arg2 = (Dali::Vector3 *)jarg2;
6493   if (!arg2) {
6494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6495     return 0;
6496   }
6497   {
6498     try {
6499       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6500     } catch (std::out_of_range& e) {
6501       {
6502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6503       };
6504     } catch (std::exception& e) {
6505       {
6506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6507       };
6508     } catch (Dali::DaliException e) {
6509       {
6510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6511       };
6512     } catch (...) {
6513       {
6514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6515       };
6516     }
6517   }
6518
6519   jresult = result;
6520   return jresult;
6521 }
6522
6523
6524 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6525   unsigned int jresult ;
6526   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6527   Dali::Vector3 *arg2 = 0 ;
6528   bool result;
6529
6530   arg1 = (Dali::Vector3 *)jarg1;
6531   arg2 = (Dali::Vector3 *)jarg2;
6532   if (!arg2) {
6533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6534     return 0;
6535   }
6536   {
6537     try {
6538       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6539     } catch (std::out_of_range& e) {
6540       {
6541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6542       };
6543     } catch (std::exception& e) {
6544       {
6545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6546       };
6547     } catch (Dali::DaliException e) {
6548       {
6549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6550       };
6551     } catch (...) {
6552       {
6553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6554       };
6555     }
6556   }
6557
6558   jresult = result;
6559   return jresult;
6560 }
6561
6562
6563 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6564   float jresult ;
6565   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6566   unsigned int arg2 ;
6567   float *result = 0 ;
6568
6569   arg1 = (Dali::Vector3 *)jarg1;
6570   arg2 = (unsigned int)jarg2;
6571   {
6572     try {
6573       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6574     } catch (std::out_of_range& e) {
6575       {
6576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6577       };
6578     } catch (std::exception& e) {
6579       {
6580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6581       };
6582     } catch (Dali::DaliException e) {
6583       {
6584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6585       };
6586     } catch (...) {
6587       {
6588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6589       };
6590     }
6591   }
6592
6593   jresult = *result;
6594   return jresult;
6595 }
6596
6597
6598 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6599   float jresult ;
6600   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6601   Dali::Vector3 *arg2 = 0 ;
6602   float result;
6603
6604   arg1 = (Dali::Vector3 *)jarg1;
6605   arg2 = (Dali::Vector3 *)jarg2;
6606   if (!arg2) {
6607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6608     return 0;
6609   }
6610   {
6611     try {
6612       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6613     } catch (std::out_of_range& e) {
6614       {
6615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6616       };
6617     } catch (std::exception& e) {
6618       {
6619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6620       };
6621     } catch (Dali::DaliException e) {
6622       {
6623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6624       };
6625     } catch (...) {
6626       {
6627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6628       };
6629     }
6630   }
6631
6632   jresult = result;
6633   return jresult;
6634 }
6635
6636
6637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6638   void * jresult ;
6639   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6640   Dali::Vector3 *arg2 = 0 ;
6641   Dali::Vector3 result;
6642
6643   arg1 = (Dali::Vector3 *)jarg1;
6644   arg2 = (Dali::Vector3 *)jarg2;
6645   if (!arg2) {
6646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6647     return 0;
6648   }
6649   {
6650     try {
6651       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6652     } catch (std::out_of_range& e) {
6653       {
6654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6655       };
6656     } catch (std::exception& e) {
6657       {
6658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6659       };
6660     } catch (Dali::DaliException e) {
6661       {
6662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6663       };
6664     } catch (...) {
6665       {
6666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6667       };
6668     }
6669   }
6670
6671   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6672   return jresult;
6673 }
6674
6675
6676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6677   float jresult ;
6678   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6679   float result;
6680
6681   arg1 = (Dali::Vector3 *)jarg1;
6682   {
6683     try {
6684       result = (float)((Dali::Vector3 const *)arg1)->Length();
6685     } catch (std::out_of_range& e) {
6686       {
6687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6688       };
6689     } catch (std::exception& e) {
6690       {
6691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6692       };
6693     } catch (Dali::DaliException e) {
6694       {
6695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6696       };
6697     } catch (...) {
6698       {
6699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6700       };
6701     }
6702   }
6703
6704   jresult = result;
6705   return jresult;
6706 }
6707
6708
6709 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6710   float jresult ;
6711   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6712   float result;
6713
6714   arg1 = (Dali::Vector3 *)jarg1;
6715   {
6716     try {
6717       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6718     } catch (std::out_of_range& e) {
6719       {
6720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6721       };
6722     } catch (std::exception& e) {
6723       {
6724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6725       };
6726     } catch (Dali::DaliException e) {
6727       {
6728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6729       };
6730     } catch (...) {
6731       {
6732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6733       };
6734     }
6735   }
6736
6737   jresult = result;
6738   return jresult;
6739 }
6740
6741
6742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6743   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6744
6745   arg1 = (Dali::Vector3 *)jarg1;
6746   {
6747     try {
6748       (arg1)->Normalize();
6749     } catch (std::out_of_range& e) {
6750       {
6751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6752       };
6753     } catch (std::exception& e) {
6754       {
6755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6756       };
6757     } catch (Dali::DaliException e) {
6758       {
6759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6760       };
6761     } catch (...) {
6762       {
6763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6764       };
6765     }
6766   }
6767
6768 }
6769
6770
6771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6772   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6773   Dali::Vector3 *arg2 = 0 ;
6774   Dali::Vector3 *arg3 = 0 ;
6775
6776   arg1 = (Dali::Vector3 *)jarg1;
6777   arg2 = (Dali::Vector3 *)jarg2;
6778   if (!arg2) {
6779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6780     return ;
6781   }
6782   arg3 = (Dali::Vector3 *)jarg3;
6783   if (!arg3) {
6784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6785     return ;
6786   }
6787   {
6788     try {
6789       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6790     } catch (std::out_of_range& e) {
6791       {
6792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6793       };
6794     } catch (std::exception& e) {
6795       {
6796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6797       };
6798     } catch (Dali::DaliException e) {
6799       {
6800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6801       };
6802     } catch (...) {
6803       {
6804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6805       };
6806     }
6807   }
6808
6809 }
6810
6811
6812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6813   void * jresult ;
6814   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6815   float *result = 0 ;
6816
6817   arg1 = (Dali::Vector3 *)jarg1;
6818   {
6819     try {
6820       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6821     } catch (std::out_of_range& e) {
6822       {
6823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6824       };
6825     } catch (std::exception& e) {
6826       {
6827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6828       };
6829     } catch (Dali::DaliException e) {
6830       {
6831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6832       };
6833     } catch (...) {
6834       {
6835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6836       };
6837     }
6838   }
6839
6840   jresult = (void *)result;
6841   return jresult;
6842 }
6843
6844
6845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6846   void * jresult ;
6847   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6848   Dali::Vector2 *result = 0 ;
6849
6850   arg1 = (Dali::Vector3 *)jarg1;
6851   {
6852     try {
6853       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6854     } catch (std::out_of_range& e) {
6855       {
6856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6857       };
6858     } catch (std::exception& e) {
6859       {
6860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6861       };
6862     } catch (Dali::DaliException e) {
6863       {
6864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6865       };
6866     } catch (...) {
6867       {
6868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6869       };
6870     }
6871   }
6872
6873   jresult = (void *)result;
6874   return jresult;
6875 }
6876
6877
6878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6879   void * jresult ;
6880   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6881   Dali::Vector2 *result = 0 ;
6882
6883   arg1 = (Dali::Vector3 *)jarg1;
6884   {
6885     try {
6886       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6887     } catch (std::out_of_range& e) {
6888       {
6889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6890       };
6891     } catch (std::exception& e) {
6892       {
6893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6894       };
6895     } catch (Dali::DaliException e) {
6896       {
6897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6898       };
6899     } catch (...) {
6900       {
6901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6902       };
6903     }
6904   }
6905
6906   jresult = (void *)result;
6907   return jresult;
6908 }
6909
6910
6911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6912   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6913   float arg2 ;
6914
6915   arg1 = (Dali::Vector3 *)jarg1;
6916   arg2 = (float)jarg2;
6917   if (arg1) (arg1)->x = arg2;
6918 }
6919
6920
6921 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6922   float jresult ;
6923   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6924   float result;
6925
6926   arg1 = (Dali::Vector3 *)jarg1;
6927   result = (float) ((arg1)->x);
6928   jresult = result;
6929   return jresult;
6930 }
6931
6932
6933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6934   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6935   float arg2 ;
6936
6937   arg1 = (Dali::Vector3 *)jarg1;
6938   arg2 = (float)jarg2;
6939   if (arg1) (arg1)->width = arg2;
6940 }
6941
6942
6943 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6944   float jresult ;
6945   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6946   float result;
6947
6948   arg1 = (Dali::Vector3 *)jarg1;
6949   result = (float) ((arg1)->width);
6950   jresult = result;
6951   return jresult;
6952 }
6953
6954
6955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6956   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6957   float arg2 ;
6958
6959   arg1 = (Dali::Vector3 *)jarg1;
6960   arg2 = (float)jarg2;
6961   if (arg1) (arg1)->r = arg2;
6962 }
6963
6964
6965 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6966   float jresult ;
6967   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6968   float result;
6969
6970   arg1 = (Dali::Vector3 *)jarg1;
6971   result = (float) ((arg1)->r);
6972   jresult = result;
6973   return jresult;
6974 }
6975
6976
6977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6978   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6979   float arg2 ;
6980
6981   arg1 = (Dali::Vector3 *)jarg1;
6982   arg2 = (float)jarg2;
6983   if (arg1) (arg1)->y = arg2;
6984 }
6985
6986
6987 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6988   float jresult ;
6989   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6990   float result;
6991
6992   arg1 = (Dali::Vector3 *)jarg1;
6993   result = (float) ((arg1)->y);
6994   jresult = result;
6995   return jresult;
6996 }
6997
6998
6999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
7000   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7001   float arg2 ;
7002
7003   arg1 = (Dali::Vector3 *)jarg1;
7004   arg2 = (float)jarg2;
7005   if (arg1) (arg1)->height = arg2;
7006 }
7007
7008
7009 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
7010   float jresult ;
7011   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7012   float result;
7013
7014   arg1 = (Dali::Vector3 *)jarg1;
7015   result = (float) ((arg1)->height);
7016   jresult = result;
7017   return jresult;
7018 }
7019
7020
7021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
7022   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7023   float arg2 ;
7024
7025   arg1 = (Dali::Vector3 *)jarg1;
7026   arg2 = (float)jarg2;
7027   if (arg1) (arg1)->g = arg2;
7028 }
7029
7030
7031 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
7032   float jresult ;
7033   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7034   float result;
7035
7036   arg1 = (Dali::Vector3 *)jarg1;
7037   result = (float) ((arg1)->g);
7038   jresult = result;
7039   return jresult;
7040 }
7041
7042
7043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
7044   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7045   float arg2 ;
7046
7047   arg1 = (Dali::Vector3 *)jarg1;
7048   arg2 = (float)jarg2;
7049   if (arg1) (arg1)->z = arg2;
7050 }
7051
7052
7053 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7054   float jresult ;
7055   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7056   float result;
7057
7058   arg1 = (Dali::Vector3 *)jarg1;
7059   result = (float) ((arg1)->z);
7060   jresult = result;
7061   return jresult;
7062 }
7063
7064
7065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7066   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7067   float arg2 ;
7068
7069   arg1 = (Dali::Vector3 *)jarg1;
7070   arg2 = (float)jarg2;
7071   if (arg1) (arg1)->depth = arg2;
7072 }
7073
7074
7075 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7076   float jresult ;
7077   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7078   float result;
7079
7080   arg1 = (Dali::Vector3 *)jarg1;
7081   result = (float) ((arg1)->depth);
7082   jresult = result;
7083   return jresult;
7084 }
7085
7086
7087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7088   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7089   float arg2 ;
7090
7091   arg1 = (Dali::Vector3 *)jarg1;
7092   arg2 = (float)jarg2;
7093   if (arg1) (arg1)->b = arg2;
7094 }
7095
7096
7097 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7098   float jresult ;
7099   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7100   float result;
7101
7102   arg1 = (Dali::Vector3 *)jarg1;
7103   result = (float) ((arg1)->b);
7104   jresult = result;
7105   return jresult;
7106 }
7107
7108
7109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7110   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7111
7112   arg1 = (Dali::Vector3 *)jarg1;
7113   {
7114     try {
7115       delete arg1;
7116     } catch (std::out_of_range& e) {
7117       {
7118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7119       };
7120     } catch (std::exception& e) {
7121       {
7122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7123       };
7124     } catch (Dali::DaliException e) {
7125       {
7126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7127       };
7128     } catch (...) {
7129       {
7130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7131       };
7132     }
7133   }
7134
7135 }
7136
7137
7138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7139   void * jresult ;
7140   Dali::Vector3 *arg1 = 0 ;
7141   Dali::Vector3 *arg2 = 0 ;
7142   Dali::Vector3 result;
7143
7144   arg1 = (Dali::Vector3 *)jarg1;
7145   if (!arg1) {
7146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7147     return 0;
7148   }
7149   arg2 = (Dali::Vector3 *)jarg2;
7150   if (!arg2) {
7151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7152     return 0;
7153   }
7154   {
7155     try {
7156       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7157     } catch (std::out_of_range& e) {
7158       {
7159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7160       };
7161     } catch (std::exception& e) {
7162       {
7163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7164       };
7165     } catch (Dali::DaliException e) {
7166       {
7167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7168       };
7169     } catch (...) {
7170       {
7171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7172       };
7173     }
7174   }
7175
7176   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7177   return jresult;
7178 }
7179
7180
7181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7182   void * jresult ;
7183   Dali::Vector3 *arg1 = 0 ;
7184   Dali::Vector3 *arg2 = 0 ;
7185   Dali::Vector3 result;
7186
7187   arg1 = (Dali::Vector3 *)jarg1;
7188   if (!arg1) {
7189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7190     return 0;
7191   }
7192   arg2 = (Dali::Vector3 *)jarg2;
7193   if (!arg2) {
7194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7195     return 0;
7196   }
7197   {
7198     try {
7199       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7200     } catch (std::out_of_range& e) {
7201       {
7202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7203       };
7204     } catch (std::exception& e) {
7205       {
7206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7207       };
7208     } catch (Dali::DaliException e) {
7209       {
7210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7211       };
7212     } catch (...) {
7213       {
7214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7215       };
7216     }
7217   }
7218
7219   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7220   return jresult;
7221 }
7222
7223
7224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7225   void * jresult ;
7226   Dali::Vector3 *arg1 = 0 ;
7227   float *arg2 = 0 ;
7228   float *arg3 = 0 ;
7229   float temp2 ;
7230   float temp3 ;
7231   Dali::Vector3 result;
7232
7233   arg1 = (Dali::Vector3 *)jarg1;
7234   if (!arg1) {
7235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7236     return 0;
7237   }
7238   temp2 = (float)jarg2;
7239   arg2 = &temp2;
7240   temp3 = (float)jarg3;
7241   arg3 = &temp3;
7242   {
7243     try {
7244       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7245     } catch (std::out_of_range& e) {
7246       {
7247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7248       };
7249     } catch (std::exception& e) {
7250       {
7251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7252       };
7253     } catch (Dali::DaliException e) {
7254       {
7255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7256       };
7257     } catch (...) {
7258       {
7259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7260       };
7261     }
7262   }
7263
7264   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7265   return jresult;
7266 }
7267
7268
7269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7270   void * jresult ;
7271   Dali::Vector4 *result = 0 ;
7272
7273   {
7274     try {
7275       result = (Dali::Vector4 *)new Dali::Vector4();
7276     } catch (std::out_of_range& e) {
7277       {
7278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7279       };
7280     } catch (std::exception& e) {
7281       {
7282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7283       };
7284     } catch (Dali::DaliException e) {
7285       {
7286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7287       };
7288     } catch (...) {
7289       {
7290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7291       };
7292     }
7293   }
7294
7295   jresult = (void *)result;
7296   return jresult;
7297 }
7298
7299
7300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7301   void * jresult ;
7302   float arg1 ;
7303   float arg2 ;
7304   float arg3 ;
7305   float arg4 ;
7306   Dali::Vector4 *result = 0 ;
7307
7308   arg1 = (float)jarg1;
7309   arg2 = (float)jarg2;
7310   arg3 = (float)jarg3;
7311   arg4 = (float)jarg4;
7312   {
7313     try {
7314       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7315     } catch (std::out_of_range& e) {
7316       {
7317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7318       };
7319     } catch (std::exception& e) {
7320       {
7321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7322       };
7323     } catch (Dali::DaliException e) {
7324       {
7325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7326       };
7327     } catch (...) {
7328       {
7329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7330       };
7331     }
7332   }
7333
7334   jresult = (void *)result;
7335   return jresult;
7336 }
7337
7338
7339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7340   void * jresult ;
7341   float *arg1 = (float *) 0 ;
7342   Dali::Vector4 *result = 0 ;
7343
7344   arg1 = jarg1;
7345   {
7346     try {
7347       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7348     } catch (std::out_of_range& e) {
7349       {
7350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7351       };
7352     } catch (std::exception& e) {
7353       {
7354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7355       };
7356     } catch (Dali::DaliException e) {
7357       {
7358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7359       };
7360     } catch (...) {
7361       {
7362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7363       };
7364     }
7365   }
7366
7367   jresult = (void *)result;
7368
7369
7370   return jresult;
7371 }
7372
7373
7374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7375   void * jresult ;
7376   Dali::Vector2 *arg1 = 0 ;
7377   Dali::Vector4 *result = 0 ;
7378
7379   arg1 = (Dali::Vector2 *)jarg1;
7380   if (!arg1) {
7381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7382     return 0;
7383   }
7384   {
7385     try {
7386       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7387     } catch (std::out_of_range& e) {
7388       {
7389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7390       };
7391     } catch (std::exception& e) {
7392       {
7393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7394       };
7395     } catch (Dali::DaliException e) {
7396       {
7397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7398       };
7399     } catch (...) {
7400       {
7401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7402       };
7403     }
7404   }
7405
7406   jresult = (void *)result;
7407   return jresult;
7408 }
7409
7410
7411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7412   void * jresult ;
7413   Dali::Vector3 *arg1 = 0 ;
7414   Dali::Vector4 *result = 0 ;
7415
7416   arg1 = (Dali::Vector3 *)jarg1;
7417   if (!arg1) {
7418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7419     return 0;
7420   }
7421   {
7422     try {
7423       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7424     } catch (std::out_of_range& e) {
7425       {
7426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7427       };
7428     } catch (std::exception& e) {
7429       {
7430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7431       };
7432     } catch (Dali::DaliException e) {
7433       {
7434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7435       };
7436     } catch (...) {
7437       {
7438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7439       };
7440     }
7441   }
7442
7443   jresult = (void *)result;
7444   return jresult;
7445 }
7446
7447
7448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7449   void * jresult ;
7450   Dali::Vector4 *result = 0 ;
7451
7452   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7453   jresult = (void *)result;
7454   return jresult;
7455 }
7456
7457
7458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7459   void * jresult ;
7460   Dali::Vector4 *result = 0 ;
7461
7462   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7463   jresult = (void *)result;
7464   return jresult;
7465 }
7466
7467
7468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7469   void * jresult ;
7470   Dali::Vector4 *result = 0 ;
7471
7472   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7473   jresult = (void *)result;
7474   return jresult;
7475 }
7476
7477
7478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7479   void * jresult ;
7480   Dali::Vector4 *result = 0 ;
7481
7482   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7483   jresult = (void *)result;
7484   return jresult;
7485 }
7486
7487
7488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7489   void * jresult ;
7490   Dali::Vector4 *result = 0 ;
7491
7492   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7493   jresult = (void *)result;
7494   return jresult;
7495 }
7496
7497
7498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7499   void * jresult ;
7500   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7501   float *arg2 = (float *) 0 ;
7502   Dali::Vector4 *result = 0 ;
7503
7504   arg1 = (Dali::Vector4 *)jarg1;
7505   arg2 = jarg2;
7506   {
7507     try {
7508       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7509     } catch (std::out_of_range& e) {
7510       {
7511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7512       };
7513     } catch (std::exception& e) {
7514       {
7515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7516       };
7517     } catch (Dali::DaliException e) {
7518       {
7519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7520       };
7521     } catch (...) {
7522       {
7523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7524       };
7525     }
7526   }
7527
7528   jresult = (void *)result;
7529
7530
7531   return jresult;
7532 }
7533
7534
7535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7536   void * jresult ;
7537   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7538   Dali::Vector2 *arg2 = 0 ;
7539   Dali::Vector4 *result = 0 ;
7540
7541   arg1 = (Dali::Vector4 *)jarg1;
7542   arg2 = (Dali::Vector2 *)jarg2;
7543   if (!arg2) {
7544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7545     return 0;
7546   }
7547   {
7548     try {
7549       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7550     } catch (std::out_of_range& e) {
7551       {
7552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7553       };
7554     } catch (std::exception& e) {
7555       {
7556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7557       };
7558     } catch (Dali::DaliException e) {
7559       {
7560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7561       };
7562     } catch (...) {
7563       {
7564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7565       };
7566     }
7567   }
7568
7569   jresult = (void *)result;
7570   return jresult;
7571 }
7572
7573
7574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7575   void * jresult ;
7576   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7577   Dali::Vector3 *arg2 = 0 ;
7578   Dali::Vector4 *result = 0 ;
7579
7580   arg1 = (Dali::Vector4 *)jarg1;
7581   arg2 = (Dali::Vector3 *)jarg2;
7582   if (!arg2) {
7583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7584     return 0;
7585   }
7586   {
7587     try {
7588       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7589     } catch (std::out_of_range& e) {
7590       {
7591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7592       };
7593     } catch (std::exception& e) {
7594       {
7595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7596       };
7597     } catch (Dali::DaliException e) {
7598       {
7599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7600       };
7601     } catch (...) {
7602       {
7603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7604       };
7605     }
7606   }
7607
7608   jresult = (void *)result;
7609   return jresult;
7610 }
7611
7612
7613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7614   void * jresult ;
7615   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7616   Dali::Vector4 *arg2 = 0 ;
7617   Dali::Vector4 result;
7618
7619   arg1 = (Dali::Vector4 *)jarg1;
7620   arg2 = (Dali::Vector4 *)jarg2;
7621   if (!arg2) {
7622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7623     return 0;
7624   }
7625   {
7626     try {
7627       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7628     } catch (std::out_of_range& e) {
7629       {
7630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7631       };
7632     } catch (std::exception& e) {
7633       {
7634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7635       };
7636     } catch (Dali::DaliException e) {
7637       {
7638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7639       };
7640     } catch (...) {
7641       {
7642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7643       };
7644     }
7645   }
7646
7647   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7648   return jresult;
7649 }
7650
7651
7652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7653   void * jresult ;
7654   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7655   Dali::Vector4 *arg2 = 0 ;
7656   Dali::Vector4 *result = 0 ;
7657
7658   arg1 = (Dali::Vector4 *)jarg1;
7659   arg2 = (Dali::Vector4 *)jarg2;
7660   if (!arg2) {
7661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7662     return 0;
7663   }
7664   {
7665     try {
7666       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7667     } catch (std::out_of_range& e) {
7668       {
7669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7670       };
7671     } catch (std::exception& e) {
7672       {
7673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7674       };
7675     } catch (Dali::DaliException e) {
7676       {
7677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7678       };
7679     } catch (...) {
7680       {
7681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7682       };
7683     }
7684   }
7685
7686   jresult = (void *)result;
7687   return jresult;
7688 }
7689
7690
7691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7692   void * jresult ;
7693   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7694   Dali::Vector4 *arg2 = 0 ;
7695   Dali::Vector4 result;
7696
7697   arg1 = (Dali::Vector4 *)jarg1;
7698   arg2 = (Dali::Vector4 *)jarg2;
7699   if (!arg2) {
7700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7701     return 0;
7702   }
7703   {
7704     try {
7705       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7706     } catch (std::out_of_range& e) {
7707       {
7708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7709       };
7710     } catch (std::exception& e) {
7711       {
7712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7713       };
7714     } catch (Dali::DaliException e) {
7715       {
7716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7717       };
7718     } catch (...) {
7719       {
7720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7721       };
7722     }
7723   }
7724
7725   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7726   return jresult;
7727 }
7728
7729
7730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7731   void * jresult ;
7732   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7733   Dali::Vector4 *arg2 = 0 ;
7734   Dali::Vector4 *result = 0 ;
7735
7736   arg1 = (Dali::Vector4 *)jarg1;
7737   arg2 = (Dali::Vector4 *)jarg2;
7738   if (!arg2) {
7739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7740     return 0;
7741   }
7742   {
7743     try {
7744       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7745     } catch (std::out_of_range& e) {
7746       {
7747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7748       };
7749     } catch (std::exception& e) {
7750       {
7751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7752       };
7753     } catch (Dali::DaliException e) {
7754       {
7755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7756       };
7757     } catch (...) {
7758       {
7759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7760       };
7761     }
7762   }
7763
7764   jresult = (void *)result;
7765   return jresult;
7766 }
7767
7768
7769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7770   void * jresult ;
7771   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7772   Dali::Vector4 *arg2 = 0 ;
7773   Dali::Vector4 result;
7774
7775   arg1 = (Dali::Vector4 *)jarg1;
7776   arg2 = (Dali::Vector4 *)jarg2;
7777   if (!arg2) {
7778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7779     return 0;
7780   }
7781   {
7782     try {
7783       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7784     } catch (std::out_of_range& e) {
7785       {
7786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7787       };
7788     } catch (std::exception& e) {
7789       {
7790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7791       };
7792     } catch (Dali::DaliException e) {
7793       {
7794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7795       };
7796     } catch (...) {
7797       {
7798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7799       };
7800     }
7801   }
7802
7803   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7804   return jresult;
7805 }
7806
7807
7808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7809   void * jresult ;
7810   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7811   float arg2 ;
7812   Dali::Vector4 result;
7813
7814   arg1 = (Dali::Vector4 *)jarg1;
7815   arg2 = (float)jarg2;
7816   {
7817     try {
7818       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7819     } catch (std::out_of_range& e) {
7820       {
7821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7822       };
7823     } catch (std::exception& e) {
7824       {
7825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7826       };
7827     } catch (Dali::DaliException e) {
7828       {
7829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7830       };
7831     } catch (...) {
7832       {
7833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7834       };
7835     }
7836   }
7837
7838   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7839   return jresult;
7840 }
7841
7842
7843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7844   void * jresult ;
7845   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7846   Dali::Vector4 *arg2 = 0 ;
7847   Dali::Vector4 *result = 0 ;
7848
7849   arg1 = (Dali::Vector4 *)jarg1;
7850   arg2 = (Dali::Vector4 *)jarg2;
7851   if (!arg2) {
7852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7853     return 0;
7854   }
7855   {
7856     try {
7857       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7858     } catch (std::out_of_range& e) {
7859       {
7860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7861       };
7862     } catch (std::exception& e) {
7863       {
7864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7865       };
7866     } catch (Dali::DaliException e) {
7867       {
7868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7869       };
7870     } catch (...) {
7871       {
7872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7873       };
7874     }
7875   }
7876
7877   jresult = (void *)result;
7878   return jresult;
7879 }
7880
7881
7882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7883   void * jresult ;
7884   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7885   float arg2 ;
7886   Dali::Vector4 *result = 0 ;
7887
7888   arg1 = (Dali::Vector4 *)jarg1;
7889   arg2 = (float)jarg2;
7890   {
7891     try {
7892       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7893     } catch (std::out_of_range& e) {
7894       {
7895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7896       };
7897     } catch (std::exception& e) {
7898       {
7899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7900       };
7901     } catch (Dali::DaliException e) {
7902       {
7903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7904       };
7905     } catch (...) {
7906       {
7907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7908       };
7909     }
7910   }
7911
7912   jresult = (void *)result;
7913   return jresult;
7914 }
7915
7916
7917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7918   void * jresult ;
7919   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7920   Dali::Vector4 *arg2 = 0 ;
7921   Dali::Vector4 result;
7922
7923   arg1 = (Dali::Vector4 *)jarg1;
7924   arg2 = (Dali::Vector4 *)jarg2;
7925   if (!arg2) {
7926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7927     return 0;
7928   }
7929   {
7930     try {
7931       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7932     } catch (std::out_of_range& e) {
7933       {
7934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7935       };
7936     } catch (std::exception& e) {
7937       {
7938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7939       };
7940     } catch (Dali::DaliException e) {
7941       {
7942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7943       };
7944     } catch (...) {
7945       {
7946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7947       };
7948     }
7949   }
7950
7951   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7952   return jresult;
7953 }
7954
7955
7956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7957   void * jresult ;
7958   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7959   float arg2 ;
7960   Dali::Vector4 result;
7961
7962   arg1 = (Dali::Vector4 *)jarg1;
7963   arg2 = (float)jarg2;
7964   {
7965     try {
7966       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7967     } catch (std::out_of_range& e) {
7968       {
7969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7970       };
7971     } catch (std::exception& e) {
7972       {
7973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7974       };
7975     } catch (Dali::DaliException e) {
7976       {
7977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7978       };
7979     } catch (...) {
7980       {
7981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7982       };
7983     }
7984   }
7985
7986   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7987   return jresult;
7988 }
7989
7990
7991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7992   void * jresult ;
7993   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7994   Dali::Vector4 *arg2 = 0 ;
7995   Dali::Vector4 *result = 0 ;
7996
7997   arg1 = (Dali::Vector4 *)jarg1;
7998   arg2 = (Dali::Vector4 *)jarg2;
7999   if (!arg2) {
8000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8001     return 0;
8002   }
8003   {
8004     try {
8005       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
8006     } catch (std::out_of_range& e) {
8007       {
8008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8009       };
8010     } catch (std::exception& e) {
8011       {
8012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8013       };
8014     } catch (Dali::DaliException e) {
8015       {
8016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8017       };
8018     } catch (...) {
8019       {
8020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8021       };
8022     }
8023   }
8024
8025   jresult = (void *)result;
8026   return jresult;
8027 }
8028
8029
8030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
8031   void * jresult ;
8032   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8033   float arg2 ;
8034   Dali::Vector4 *result = 0 ;
8035
8036   arg1 = (Dali::Vector4 *)jarg1;
8037   arg2 = (float)jarg2;
8038   {
8039     try {
8040       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
8041     } catch (std::out_of_range& e) {
8042       {
8043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8044       };
8045     } catch (std::exception& e) {
8046       {
8047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8048       };
8049     } catch (Dali::DaliException e) {
8050       {
8051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8052       };
8053     } catch (...) {
8054       {
8055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8056       };
8057     }
8058   }
8059
8060   jresult = (void *)result;
8061   return jresult;
8062 }
8063
8064
8065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8066   void * jresult ;
8067   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8068   Dali::Vector4 result;
8069
8070   arg1 = (Dali::Vector4 *)jarg1;
8071   {
8072     try {
8073       result = ((Dali::Vector4 const *)arg1)->operator -();
8074     } catch (std::out_of_range& e) {
8075       {
8076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8077       };
8078     } catch (std::exception& e) {
8079       {
8080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8081       };
8082     } catch (Dali::DaliException e) {
8083       {
8084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8085       };
8086     } catch (...) {
8087       {
8088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8089       };
8090     }
8091   }
8092
8093   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8094   return jresult;
8095 }
8096
8097
8098 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8099   unsigned int jresult ;
8100   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8101   Dali::Vector4 *arg2 = 0 ;
8102   bool result;
8103
8104   arg1 = (Dali::Vector4 *)jarg1;
8105   arg2 = (Dali::Vector4 *)jarg2;
8106   if (!arg2) {
8107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8108     return 0;
8109   }
8110   {
8111     try {
8112       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8113     } catch (std::out_of_range& e) {
8114       {
8115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8116       };
8117     } catch (std::exception& e) {
8118       {
8119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8120       };
8121     } catch (Dali::DaliException e) {
8122       {
8123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8124       };
8125     } catch (...) {
8126       {
8127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8128       };
8129     }
8130   }
8131
8132   jresult = result;
8133   return jresult;
8134 }
8135
8136
8137 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8138   unsigned int jresult ;
8139   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8140   Dali::Vector4 *arg2 = 0 ;
8141   bool result;
8142
8143   arg1 = (Dali::Vector4 *)jarg1;
8144   arg2 = (Dali::Vector4 *)jarg2;
8145   if (!arg2) {
8146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8147     return 0;
8148   }
8149   {
8150     try {
8151       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8152     } catch (std::out_of_range& e) {
8153       {
8154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8155       };
8156     } catch (std::exception& e) {
8157       {
8158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8159       };
8160     } catch (Dali::DaliException e) {
8161       {
8162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8163       };
8164     } catch (...) {
8165       {
8166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8167       };
8168     }
8169   }
8170
8171   jresult = result;
8172   return jresult;
8173 }
8174
8175
8176 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8177   float jresult ;
8178   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8179   unsigned int arg2 ;
8180   float *result = 0 ;
8181
8182   arg1 = (Dali::Vector4 *)jarg1;
8183   arg2 = (unsigned int)jarg2;
8184   {
8185     try {
8186       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8187     } catch (std::out_of_range& e) {
8188       {
8189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8190       };
8191     } catch (std::exception& e) {
8192       {
8193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8194       };
8195     } catch (Dali::DaliException e) {
8196       {
8197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8198       };
8199     } catch (...) {
8200       {
8201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8202       };
8203     }
8204   }
8205
8206   jresult = *result;
8207   return jresult;
8208 }
8209
8210
8211 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8212   float jresult ;
8213   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8214   Dali::Vector3 *arg2 = 0 ;
8215   float result;
8216
8217   arg1 = (Dali::Vector4 *)jarg1;
8218   arg2 = (Dali::Vector3 *)jarg2;
8219   if (!arg2) {
8220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8221     return 0;
8222   }
8223   {
8224     try {
8225       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8226     } catch (std::out_of_range& e) {
8227       {
8228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8229       };
8230     } catch (std::exception& e) {
8231       {
8232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8233       };
8234     } catch (Dali::DaliException e) {
8235       {
8236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8237       };
8238     } catch (...) {
8239       {
8240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8241       };
8242     }
8243   }
8244
8245   jresult = result;
8246   return jresult;
8247 }
8248
8249
8250 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8251   float jresult ;
8252   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8253   Dali::Vector4 *arg2 = 0 ;
8254   float result;
8255
8256   arg1 = (Dali::Vector4 *)jarg1;
8257   arg2 = (Dali::Vector4 *)jarg2;
8258   if (!arg2) {
8259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8260     return 0;
8261   }
8262   {
8263     try {
8264       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8265     } catch (std::out_of_range& e) {
8266       {
8267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8268       };
8269     } catch (std::exception& e) {
8270       {
8271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8272       };
8273     } catch (Dali::DaliException e) {
8274       {
8275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8276       };
8277     } catch (...) {
8278       {
8279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8280       };
8281     }
8282   }
8283
8284   jresult = result;
8285   return jresult;
8286 }
8287
8288
8289 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8290   float jresult ;
8291   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8292   Dali::Vector4 *arg2 = 0 ;
8293   float result;
8294
8295   arg1 = (Dali::Vector4 *)jarg1;
8296   arg2 = (Dali::Vector4 *)jarg2;
8297   if (!arg2) {
8298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8299     return 0;
8300   }
8301   {
8302     try {
8303       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8304     } catch (std::out_of_range& e) {
8305       {
8306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8307       };
8308     } catch (std::exception& e) {
8309       {
8310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8311       };
8312     } catch (Dali::DaliException e) {
8313       {
8314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8315       };
8316     } catch (...) {
8317       {
8318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8319       };
8320     }
8321   }
8322
8323   jresult = result;
8324   return jresult;
8325 }
8326
8327
8328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8329   void * jresult ;
8330   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8331   Dali::Vector4 *arg2 = 0 ;
8332   Dali::Vector4 result;
8333
8334   arg1 = (Dali::Vector4 *)jarg1;
8335   arg2 = (Dali::Vector4 *)jarg2;
8336   if (!arg2) {
8337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8338     return 0;
8339   }
8340   {
8341     try {
8342       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8343     } catch (std::out_of_range& e) {
8344       {
8345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8346       };
8347     } catch (std::exception& e) {
8348       {
8349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8350       };
8351     } catch (Dali::DaliException e) {
8352       {
8353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8354       };
8355     } catch (...) {
8356       {
8357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8358       };
8359     }
8360   }
8361
8362   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8363   return jresult;
8364 }
8365
8366
8367 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8368   float jresult ;
8369   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8370   float result;
8371
8372   arg1 = (Dali::Vector4 *)jarg1;
8373   {
8374     try {
8375       result = (float)((Dali::Vector4 const *)arg1)->Length();
8376     } catch (std::out_of_range& e) {
8377       {
8378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8379       };
8380     } catch (std::exception& e) {
8381       {
8382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8383       };
8384     } catch (Dali::DaliException e) {
8385       {
8386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8387       };
8388     } catch (...) {
8389       {
8390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8391       };
8392     }
8393   }
8394
8395   jresult = result;
8396   return jresult;
8397 }
8398
8399
8400 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8401   float jresult ;
8402   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8403   float result;
8404
8405   arg1 = (Dali::Vector4 *)jarg1;
8406   {
8407     try {
8408       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8409     } catch (std::out_of_range& e) {
8410       {
8411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8412       };
8413     } catch (std::exception& e) {
8414       {
8415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8416       };
8417     } catch (Dali::DaliException e) {
8418       {
8419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8420       };
8421     } catch (...) {
8422       {
8423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8424       };
8425     }
8426   }
8427
8428   jresult = result;
8429   return jresult;
8430 }
8431
8432
8433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8434   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8435
8436   arg1 = (Dali::Vector4 *)jarg1;
8437   {
8438     try {
8439       (arg1)->Normalize();
8440     } catch (std::out_of_range& e) {
8441       {
8442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8443       };
8444     } catch (std::exception& e) {
8445       {
8446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8447       };
8448     } catch (Dali::DaliException e) {
8449       {
8450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8451       };
8452     } catch (...) {
8453       {
8454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8455       };
8456     }
8457   }
8458
8459 }
8460
8461
8462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8463   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8464   Dali::Vector4 *arg2 = 0 ;
8465   Dali::Vector4 *arg3 = 0 ;
8466
8467   arg1 = (Dali::Vector4 *)jarg1;
8468   arg2 = (Dali::Vector4 *)jarg2;
8469   if (!arg2) {
8470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8471     return ;
8472   }
8473   arg3 = (Dali::Vector4 *)jarg3;
8474   if (!arg3) {
8475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8476     return ;
8477   }
8478   {
8479     try {
8480       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8481     } catch (std::out_of_range& e) {
8482       {
8483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8484       };
8485     } catch (std::exception& e) {
8486       {
8487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8488       };
8489     } catch (Dali::DaliException e) {
8490       {
8491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8492       };
8493     } catch (...) {
8494       {
8495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8496       };
8497     }
8498   }
8499
8500 }
8501
8502
8503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8504   void * jresult ;
8505   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8506   float *result = 0 ;
8507
8508   arg1 = (Dali::Vector4 *)jarg1;
8509   {
8510     try {
8511       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8512     } catch (std::out_of_range& e) {
8513       {
8514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8515       };
8516     } catch (std::exception& e) {
8517       {
8518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8519       };
8520     } catch (Dali::DaliException e) {
8521       {
8522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8523       };
8524     } catch (...) {
8525       {
8526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8527       };
8528     }
8529   }
8530
8531   jresult = (void *)result;
8532   return jresult;
8533 }
8534
8535
8536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8537   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8538   float arg2 ;
8539
8540   arg1 = (Dali::Vector4 *)jarg1;
8541   arg2 = (float)jarg2;
8542   if (arg1) (arg1)->x = arg2;
8543 }
8544
8545
8546 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8547   float jresult ;
8548   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8549   float result;
8550
8551   arg1 = (Dali::Vector4 *)jarg1;
8552   result = (float) ((arg1)->x);
8553   jresult = result;
8554   return jresult;
8555 }
8556
8557
8558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8559   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8560   float arg2 ;
8561
8562   arg1 = (Dali::Vector4 *)jarg1;
8563   arg2 = (float)jarg2;
8564   if (arg1) (arg1)->r = arg2;
8565 }
8566
8567
8568 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8569   float jresult ;
8570   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8571   float result;
8572
8573   arg1 = (Dali::Vector4 *)jarg1;
8574   result = (float) ((arg1)->r);
8575   jresult = result;
8576   return jresult;
8577 }
8578
8579
8580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8581   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8582   float arg2 ;
8583
8584   arg1 = (Dali::Vector4 *)jarg1;
8585   arg2 = (float)jarg2;
8586   if (arg1) (arg1)->s = arg2;
8587 }
8588
8589
8590 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8591   float jresult ;
8592   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8593   float result;
8594
8595   arg1 = (Dali::Vector4 *)jarg1;
8596   result = (float) ((arg1)->s);
8597   jresult = result;
8598   return jresult;
8599 }
8600
8601
8602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8603   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8604   float arg2 ;
8605
8606   arg1 = (Dali::Vector4 *)jarg1;
8607   arg2 = (float)jarg2;
8608   if (arg1) (arg1)->y = arg2;
8609 }
8610
8611
8612 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8613   float jresult ;
8614   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8615   float result;
8616
8617   arg1 = (Dali::Vector4 *)jarg1;
8618   result = (float) ((arg1)->y);
8619   jresult = result;
8620   return jresult;
8621 }
8622
8623
8624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8625   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8626   float arg2 ;
8627
8628   arg1 = (Dali::Vector4 *)jarg1;
8629   arg2 = (float)jarg2;
8630   if (arg1) (arg1)->g = arg2;
8631 }
8632
8633
8634 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8635   float jresult ;
8636   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8637   float result;
8638
8639   arg1 = (Dali::Vector4 *)jarg1;
8640   result = (float) ((arg1)->g);
8641   jresult = result;
8642   return jresult;
8643 }
8644
8645
8646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8647   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8648   float arg2 ;
8649
8650   arg1 = (Dali::Vector4 *)jarg1;
8651   arg2 = (float)jarg2;
8652   if (arg1) (arg1)->t = arg2;
8653 }
8654
8655
8656 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8657   float jresult ;
8658   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8659   float result;
8660
8661   arg1 = (Dali::Vector4 *)jarg1;
8662   result = (float) ((arg1)->t);
8663   jresult = result;
8664   return jresult;
8665 }
8666
8667
8668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8669   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8670   float arg2 ;
8671
8672   arg1 = (Dali::Vector4 *)jarg1;
8673   arg2 = (float)jarg2;
8674   if (arg1) (arg1)->z = arg2;
8675 }
8676
8677
8678 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8679   float jresult ;
8680   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8681   float result;
8682
8683   arg1 = (Dali::Vector4 *)jarg1;
8684   result = (float) ((arg1)->z);
8685   jresult = result;
8686   return jresult;
8687 }
8688
8689
8690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8691   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8692   float arg2 ;
8693
8694   arg1 = (Dali::Vector4 *)jarg1;
8695   arg2 = (float)jarg2;
8696   if (arg1) (arg1)->b = arg2;
8697 }
8698
8699
8700 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8701   float jresult ;
8702   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8703   float result;
8704
8705   arg1 = (Dali::Vector4 *)jarg1;
8706   result = (float) ((arg1)->b);
8707   jresult = result;
8708   return jresult;
8709 }
8710
8711
8712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8713   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8714   float arg2 ;
8715
8716   arg1 = (Dali::Vector4 *)jarg1;
8717   arg2 = (float)jarg2;
8718   if (arg1) (arg1)->p = arg2;
8719 }
8720
8721
8722 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8723   float jresult ;
8724   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8725   float result;
8726
8727   arg1 = (Dali::Vector4 *)jarg1;
8728   result = (float) ((arg1)->p);
8729   jresult = result;
8730   return jresult;
8731 }
8732
8733
8734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8735   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8736   float arg2 ;
8737
8738   arg1 = (Dali::Vector4 *)jarg1;
8739   arg2 = (float)jarg2;
8740   if (arg1) (arg1)->w = arg2;
8741 }
8742
8743
8744 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8745   float jresult ;
8746   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8747   float result;
8748
8749   arg1 = (Dali::Vector4 *)jarg1;
8750   result = (float) ((arg1)->w);
8751   jresult = result;
8752   return jresult;
8753 }
8754
8755
8756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8757   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8758   float arg2 ;
8759
8760   arg1 = (Dali::Vector4 *)jarg1;
8761   arg2 = (float)jarg2;
8762   if (arg1) (arg1)->a = arg2;
8763 }
8764
8765
8766 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8767   float jresult ;
8768   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8769   float result;
8770
8771   arg1 = (Dali::Vector4 *)jarg1;
8772   result = (float) ((arg1)->a);
8773   jresult = result;
8774   return jresult;
8775 }
8776
8777
8778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8779   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8780   float arg2 ;
8781
8782   arg1 = (Dali::Vector4 *)jarg1;
8783   arg2 = (float)jarg2;
8784   if (arg1) (arg1)->q = arg2;
8785 }
8786
8787
8788 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8789   float jresult ;
8790   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8791   float result;
8792
8793   arg1 = (Dali::Vector4 *)jarg1;
8794   result = (float) ((arg1)->q);
8795   jresult = result;
8796   return jresult;
8797 }
8798
8799
8800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8801   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8802
8803   arg1 = (Dali::Vector4 *)jarg1;
8804   {
8805     try {
8806       delete arg1;
8807     } catch (std::out_of_range& e) {
8808       {
8809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8810       };
8811     } catch (std::exception& e) {
8812       {
8813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8814       };
8815     } catch (Dali::DaliException e) {
8816       {
8817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8818       };
8819     } catch (...) {
8820       {
8821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8822       };
8823     }
8824   }
8825
8826 }
8827
8828
8829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8830   void * jresult ;
8831   Dali::Vector4 *arg1 = 0 ;
8832   Dali::Vector4 *arg2 = 0 ;
8833   Dali::Vector4 result;
8834
8835   arg1 = (Dali::Vector4 *)jarg1;
8836   if (!arg1) {
8837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8838     return 0;
8839   }
8840   arg2 = (Dali::Vector4 *)jarg2;
8841   if (!arg2) {
8842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8843     return 0;
8844   }
8845   {
8846     try {
8847       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8848     } catch (std::out_of_range& e) {
8849       {
8850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8851       };
8852     } catch (std::exception& e) {
8853       {
8854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8855       };
8856     } catch (Dali::DaliException e) {
8857       {
8858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8859       };
8860     } catch (...) {
8861       {
8862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8863       };
8864     }
8865   }
8866
8867   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8868   return jresult;
8869 }
8870
8871
8872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8873   void * jresult ;
8874   Dali::Vector4 *arg1 = 0 ;
8875   Dali::Vector4 *arg2 = 0 ;
8876   Dali::Vector4 result;
8877
8878   arg1 = (Dali::Vector4 *)jarg1;
8879   if (!arg1) {
8880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8881     return 0;
8882   }
8883   arg2 = (Dali::Vector4 *)jarg2;
8884   if (!arg2) {
8885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8886     return 0;
8887   }
8888   {
8889     try {
8890       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8891     } catch (std::out_of_range& e) {
8892       {
8893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8894       };
8895     } catch (std::exception& e) {
8896       {
8897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8898       };
8899     } catch (Dali::DaliException e) {
8900       {
8901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8902       };
8903     } catch (...) {
8904       {
8905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8906       };
8907     }
8908   }
8909
8910   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8911   return jresult;
8912 }
8913
8914
8915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8916   void * jresult ;
8917   Dali::Vector4 *arg1 = 0 ;
8918   float *arg2 = 0 ;
8919   float *arg3 = 0 ;
8920   float temp2 ;
8921   float temp3 ;
8922   Dali::Vector4 result;
8923
8924   arg1 = (Dali::Vector4 *)jarg1;
8925   if (!arg1) {
8926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8927     return 0;
8928   }
8929   temp2 = (float)jarg2;
8930   arg2 = &temp2;
8931   temp3 = (float)jarg3;
8932   arg3 = &temp3;
8933   {
8934     try {
8935       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8936     } catch (std::out_of_range& e) {
8937       {
8938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8939       };
8940     } catch (std::exception& e) {
8941       {
8942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8943       };
8944     } catch (Dali::DaliException e) {
8945       {
8946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8947       };
8948     } catch (...) {
8949       {
8950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8951       };
8952     }
8953   }
8954
8955   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8956   return jresult;
8957 }
8958
8959
8960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8961   void * jresult ;
8962   Dali::Uint16Pair *result = 0 ;
8963
8964   {
8965     try {
8966       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8967     } catch (std::out_of_range& e) {
8968       {
8969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8970       };
8971     } catch (std::exception& e) {
8972       {
8973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8974       };
8975     } catch (Dali::DaliException e) {
8976       {
8977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8978       };
8979     } catch (...) {
8980       {
8981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8982       };
8983     }
8984   }
8985
8986   jresult = (void *)result;
8987   return jresult;
8988 }
8989
8990
8991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8992   void * jresult ;
8993   uint32_t arg1 ;
8994   uint32_t arg2 ;
8995   Dali::Uint16Pair *result = 0 ;
8996
8997   arg1 = (uint32_t)jarg1;
8998   arg2 = (uint32_t)jarg2;
8999   {
9000     try {
9001       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
9002     } catch (std::out_of_range& e) {
9003       {
9004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9005       };
9006     } catch (std::exception& e) {
9007       {
9008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9009       };
9010     } catch (Dali::DaliException e) {
9011       {
9012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9013       };
9014     } catch (...) {
9015       {
9016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9017       };
9018     }
9019   }
9020
9021   jresult = (void *)result;
9022   return jresult;
9023 }
9024
9025
9026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
9027   void * jresult ;
9028   Dali::Uint16Pair *arg1 = 0 ;
9029   Dali::Uint16Pair *result = 0 ;
9030
9031   arg1 = (Dali::Uint16Pair *)jarg1;
9032   if (!arg1) {
9033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9034     return 0;
9035   }
9036   {
9037     try {
9038       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
9039     } catch (std::out_of_range& e) {
9040       {
9041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9042       };
9043     } catch (std::exception& e) {
9044       {
9045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9046       };
9047     } catch (Dali::DaliException e) {
9048       {
9049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9050       };
9051     } catch (...) {
9052       {
9053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9054       };
9055     }
9056   }
9057
9058   jresult = (void *)result;
9059   return jresult;
9060 }
9061
9062
9063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9064   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9065   uint16_t arg2 ;
9066
9067   arg1 = (Dali::Uint16Pair *)jarg1;
9068   arg2 = (uint16_t)jarg2;
9069   {
9070     try {
9071       (arg1)->SetWidth(arg2);
9072     } catch (std::out_of_range& e) {
9073       {
9074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9075       };
9076     } catch (std::exception& e) {
9077       {
9078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9079       };
9080     } catch (Dali::DaliException e) {
9081       {
9082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9083       };
9084     } catch (...) {
9085       {
9086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9087       };
9088     }
9089   }
9090
9091 }
9092
9093
9094 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9095   unsigned short jresult ;
9096   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9097   uint16_t result;
9098
9099   arg1 = (Dali::Uint16Pair *)jarg1;
9100   {
9101     try {
9102       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9103     } catch (std::out_of_range& e) {
9104       {
9105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9106       };
9107     } catch (std::exception& e) {
9108       {
9109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9110       };
9111     } catch (Dali::DaliException e) {
9112       {
9113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9114       };
9115     } catch (...) {
9116       {
9117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9118       };
9119     }
9120   }
9121
9122   jresult = result;
9123   return jresult;
9124 }
9125
9126
9127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9128   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9129   uint16_t arg2 ;
9130
9131   arg1 = (Dali::Uint16Pair *)jarg1;
9132   arg2 = (uint16_t)jarg2;
9133   {
9134     try {
9135       (arg1)->SetHeight(arg2);
9136     } catch (std::out_of_range& e) {
9137       {
9138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9139       };
9140     } catch (std::exception& e) {
9141       {
9142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9143       };
9144     } catch (Dali::DaliException e) {
9145       {
9146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9147       };
9148     } catch (...) {
9149       {
9150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9151       };
9152     }
9153   }
9154
9155 }
9156
9157
9158 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9159   unsigned short jresult ;
9160   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9161   uint16_t result;
9162
9163   arg1 = (Dali::Uint16Pair *)jarg1;
9164   {
9165     try {
9166       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9167     } catch (std::out_of_range& e) {
9168       {
9169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9170       };
9171     } catch (std::exception& e) {
9172       {
9173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9174       };
9175     } catch (Dali::DaliException e) {
9176       {
9177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9178       };
9179     } catch (...) {
9180       {
9181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9182       };
9183     }
9184   }
9185
9186   jresult = result;
9187   return jresult;
9188 }
9189
9190
9191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9192   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9193   uint16_t arg2 ;
9194
9195   arg1 = (Dali::Uint16Pair *)jarg1;
9196   arg2 = (uint16_t)jarg2;
9197   {
9198     try {
9199       (arg1)->SetX(arg2);
9200     } catch (std::out_of_range& e) {
9201       {
9202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9203       };
9204     } catch (std::exception& e) {
9205       {
9206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9207       };
9208     } catch (Dali::DaliException e) {
9209       {
9210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9211       };
9212     } catch (...) {
9213       {
9214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9215       };
9216     }
9217   }
9218
9219 }
9220
9221
9222 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9223   unsigned short jresult ;
9224   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9225   uint16_t result;
9226
9227   arg1 = (Dali::Uint16Pair *)jarg1;
9228   {
9229     try {
9230       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9231     } catch (std::out_of_range& e) {
9232       {
9233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9234       };
9235     } catch (std::exception& e) {
9236       {
9237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9238       };
9239     } catch (Dali::DaliException e) {
9240       {
9241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9242       };
9243     } catch (...) {
9244       {
9245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9246       };
9247     }
9248   }
9249
9250   jresult = result;
9251   return jresult;
9252 }
9253
9254
9255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9256   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9257   uint16_t arg2 ;
9258
9259   arg1 = (Dali::Uint16Pair *)jarg1;
9260   arg2 = (uint16_t)jarg2;
9261   {
9262     try {
9263       (arg1)->SetY(arg2);
9264     } catch (std::out_of_range& e) {
9265       {
9266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9267       };
9268     } catch (std::exception& e) {
9269       {
9270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9271       };
9272     } catch (Dali::DaliException e) {
9273       {
9274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9275       };
9276     } catch (...) {
9277       {
9278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9279       };
9280     }
9281   }
9282
9283 }
9284
9285
9286 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9287   unsigned short jresult ;
9288   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9289   uint16_t result;
9290
9291   arg1 = (Dali::Uint16Pair *)jarg1;
9292   {
9293     try {
9294       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9295     } catch (std::out_of_range& e) {
9296       {
9297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9298       };
9299     } catch (std::exception& e) {
9300       {
9301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9302       };
9303     } catch (Dali::DaliException e) {
9304       {
9305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9306       };
9307     } catch (...) {
9308       {
9309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9310       };
9311     }
9312   }
9313
9314   jresult = result;
9315   return jresult;
9316 }
9317
9318
9319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9320   void * jresult ;
9321   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9322   Dali::Uint16Pair *arg2 = 0 ;
9323   Dali::Uint16Pair *result = 0 ;
9324
9325   arg1 = (Dali::Uint16Pair *)jarg1;
9326   arg2 = (Dali::Uint16Pair *)jarg2;
9327   if (!arg2) {
9328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9329     return 0;
9330   }
9331   {
9332     try {
9333       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9334     } catch (std::out_of_range& e) {
9335       {
9336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9337       };
9338     } catch (std::exception& e) {
9339       {
9340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9341       };
9342     } catch (Dali::DaliException e) {
9343       {
9344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9345       };
9346     } catch (...) {
9347       {
9348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9349       };
9350     }
9351   }
9352
9353   jresult = (void *)result;
9354   return jresult;
9355 }
9356
9357
9358 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9359   unsigned int jresult ;
9360   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9361   Dali::Uint16Pair *arg2 = 0 ;
9362   bool result;
9363
9364   arg1 = (Dali::Uint16Pair *)jarg1;
9365   arg2 = (Dali::Uint16Pair *)jarg2;
9366   if (!arg2) {
9367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9368     return 0;
9369   }
9370   {
9371     try {
9372       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9373     } catch (std::out_of_range& e) {
9374       {
9375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9376       };
9377     } catch (std::exception& e) {
9378       {
9379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9380       };
9381     } catch (Dali::DaliException e) {
9382       {
9383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9384       };
9385     } catch (...) {
9386       {
9387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9388       };
9389     }
9390   }
9391
9392   jresult = result;
9393   return jresult;
9394 }
9395
9396
9397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9398   unsigned int jresult ;
9399   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9400   Dali::Uint16Pair *arg2 = 0 ;
9401   bool result;
9402
9403   arg1 = (Dali::Uint16Pair *)jarg1;
9404   arg2 = (Dali::Uint16Pair *)jarg2;
9405   if (!arg2) {
9406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9407     return 0;
9408   }
9409   {
9410     try {
9411       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9412     } catch (std::out_of_range& e) {
9413       {
9414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9415       };
9416     } catch (std::exception& e) {
9417       {
9418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9419       };
9420     } catch (Dali::DaliException e) {
9421       {
9422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9423       };
9424     } catch (...) {
9425       {
9426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9427       };
9428     }
9429   }
9430
9431   jresult = result;
9432   return jresult;
9433 }
9434
9435
9436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9437   unsigned int jresult ;
9438   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9439   Dali::Uint16Pair *arg2 = 0 ;
9440   bool result;
9441
9442   arg1 = (Dali::Uint16Pair *)jarg1;
9443   arg2 = (Dali::Uint16Pair *)jarg2;
9444   if (!arg2) {
9445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9446     return 0;
9447   }
9448   {
9449     try {
9450       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9451     } catch (std::out_of_range& e) {
9452       {
9453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9454       };
9455     } catch (std::exception& e) {
9456       {
9457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9458       };
9459     } catch (Dali::DaliException e) {
9460       {
9461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9462       };
9463     } catch (...) {
9464       {
9465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9466       };
9467     }
9468   }
9469
9470   jresult = result;
9471   return jresult;
9472 }
9473
9474
9475 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9476   unsigned int jresult ;
9477   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9478   Dali::Uint16Pair *arg2 = 0 ;
9479   bool result;
9480
9481   arg1 = (Dali::Uint16Pair *)jarg1;
9482   arg2 = (Dali::Uint16Pair *)jarg2;
9483   if (!arg2) {
9484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9485     return 0;
9486   }
9487   {
9488     try {
9489       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9490     } catch (std::out_of_range& e) {
9491       {
9492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9493       };
9494     } catch (std::exception& e) {
9495       {
9496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9497       };
9498     } catch (Dali::DaliException e) {
9499       {
9500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9501       };
9502     } catch (...) {
9503       {
9504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9505       };
9506     }
9507   }
9508
9509   jresult = result;
9510   return jresult;
9511 }
9512
9513
9514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9515   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9516
9517   arg1 = (Dali::Uint16Pair *)jarg1;
9518   {
9519     try {
9520       delete arg1;
9521     } catch (std::out_of_range& e) {
9522       {
9523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9524       };
9525     } catch (std::exception& e) {
9526       {
9527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9528       };
9529     } catch (Dali::DaliException e) {
9530       {
9531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9532       };
9533     } catch (...) {
9534       {
9535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9536       };
9537     }
9538   }
9539
9540 }
9541
9542
9543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9544   void * jresult ;
9545   Dali::Degree *result = 0 ;
9546
9547   {
9548     try {
9549       result = (Dali::Degree *)new Dali::Degree();
9550     } catch (std::out_of_range& e) {
9551       {
9552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9553       };
9554     } catch (std::exception& e) {
9555       {
9556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9557       };
9558     } catch (Dali::DaliException e) {
9559       {
9560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9561       };
9562     } catch (...) {
9563       {
9564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9565       };
9566     }
9567   }
9568
9569   jresult = (void *)result;
9570   return jresult;
9571 }
9572
9573
9574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9575   void * jresult ;
9576   float arg1 ;
9577   Dali::Degree *result = 0 ;
9578
9579   arg1 = (float)jarg1;
9580   {
9581     try {
9582       result = (Dali::Degree *)new Dali::Degree(arg1);
9583     } catch (std::out_of_range& e) {
9584       {
9585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9586       };
9587     } catch (std::exception& e) {
9588       {
9589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9590       };
9591     } catch (Dali::DaliException e) {
9592       {
9593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9594       };
9595     } catch (...) {
9596       {
9597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9598       };
9599     }
9600   }
9601
9602   jresult = (void *)result;
9603   return jresult;
9604 }
9605
9606
9607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9608   void * jresult ;
9609   Dali::Radian arg1 ;
9610   Dali::Radian *argp1 ;
9611   Dali::Degree *result = 0 ;
9612
9613   argp1 = (Dali::Radian *)jarg1;
9614   if (!argp1) {
9615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9616     return 0;
9617   }
9618   arg1 = *argp1;
9619   {
9620     try {
9621       result = (Dali::Degree *)new Dali::Degree(arg1);
9622     } catch (std::out_of_range& e) {
9623       {
9624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9625       };
9626     } catch (std::exception& e) {
9627       {
9628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9629       };
9630     } catch (Dali::DaliException e) {
9631       {
9632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9633       };
9634     } catch (...) {
9635       {
9636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9637       };
9638     }
9639   }
9640
9641   jresult = (void *)result;
9642   return jresult;
9643 }
9644
9645
9646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9647   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9648   float arg2 ;
9649
9650   arg1 = (Dali::Degree *)jarg1;
9651   arg2 = (float)jarg2;
9652   if (arg1) (arg1)->degree = arg2;
9653 }
9654
9655
9656 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9657   float jresult ;
9658   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9659   float result;
9660
9661   arg1 = (Dali::Degree *)jarg1;
9662   result = (float) ((arg1)->degree);
9663   jresult = result;
9664   return jresult;
9665 }
9666
9667
9668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9669   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9670
9671   arg1 = (Dali::Degree *)jarg1;
9672   {
9673     try {
9674       delete arg1;
9675     } catch (std::out_of_range& e) {
9676       {
9677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9678       };
9679     } catch (std::exception& e) {
9680       {
9681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9682       };
9683     } catch (Dali::DaliException e) {
9684       {
9685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9686       };
9687     } catch (...) {
9688       {
9689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9690       };
9691     }
9692   }
9693
9694 }
9695
9696
9697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9698   void * jresult ;
9699   Dali::Radian *result = 0 ;
9700
9701   result = (Dali::Radian *)&Dali::ANGLE_360;
9702   jresult = (void *)result;
9703   return jresult;
9704 }
9705
9706
9707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9708   void * jresult ;
9709   Dali::Radian *result = 0 ;
9710
9711   result = (Dali::Radian *)&Dali::ANGLE_315;
9712   jresult = (void *)result;
9713   return jresult;
9714 }
9715
9716
9717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9718   void * jresult ;
9719   Dali::Radian *result = 0 ;
9720
9721   result = (Dali::Radian *)&Dali::ANGLE_270;
9722   jresult = (void *)result;
9723   return jresult;
9724 }
9725
9726
9727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9728   void * jresult ;
9729   Dali::Radian *result = 0 ;
9730
9731   result = (Dali::Radian *)&Dali::ANGLE_225;
9732   jresult = (void *)result;
9733   return jresult;
9734 }
9735
9736
9737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9738   void * jresult ;
9739   Dali::Radian *result = 0 ;
9740
9741   result = (Dali::Radian *)&Dali::ANGLE_180;
9742   jresult = (void *)result;
9743   return jresult;
9744 }
9745
9746
9747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9748   void * jresult ;
9749   Dali::Radian *result = 0 ;
9750
9751   result = (Dali::Radian *)&Dali::ANGLE_135;
9752   jresult = (void *)result;
9753   return jresult;
9754 }
9755
9756
9757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9758   void * jresult ;
9759   Dali::Radian *result = 0 ;
9760
9761   result = (Dali::Radian *)&Dali::ANGLE_120;
9762   jresult = (void *)result;
9763   return jresult;
9764 }
9765
9766
9767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9768   void * jresult ;
9769   Dali::Radian *result = 0 ;
9770
9771   result = (Dali::Radian *)&Dali::ANGLE_90;
9772   jresult = (void *)result;
9773   return jresult;
9774 }
9775
9776
9777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9778   void * jresult ;
9779   Dali::Radian *result = 0 ;
9780
9781   result = (Dali::Radian *)&Dali::ANGLE_60;
9782   jresult = (void *)result;
9783   return jresult;
9784 }
9785
9786
9787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9788   void * jresult ;
9789   Dali::Radian *result = 0 ;
9790
9791   result = (Dali::Radian *)&Dali::ANGLE_45;
9792   jresult = (void *)result;
9793   return jresult;
9794 }
9795
9796
9797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9798   void * jresult ;
9799   Dali::Radian *result = 0 ;
9800
9801   result = (Dali::Radian *)&Dali::ANGLE_30;
9802   jresult = (void *)result;
9803   return jresult;
9804 }
9805
9806
9807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9808   void * jresult ;
9809   Dali::Radian *result = 0 ;
9810
9811   result = (Dali::Radian *)&Dali::ANGLE_0;
9812   jresult = (void *)result;
9813   return jresult;
9814 }
9815
9816
9817 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9818   unsigned int jresult ;
9819   Dali::Degree *arg1 = 0 ;
9820   Dali::Degree *arg2 = 0 ;
9821   bool result;
9822
9823   arg1 = (Dali::Degree *)jarg1;
9824   if (!arg1) {
9825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9826     return 0;
9827   }
9828   arg2 = (Dali::Degree *)jarg2;
9829   if (!arg2) {
9830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9831     return 0;
9832   }
9833   {
9834     try {
9835       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9836     } catch (std::out_of_range& e) {
9837       {
9838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9839       };
9840     } catch (std::exception& e) {
9841       {
9842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9843       };
9844     } catch (Dali::DaliException e) {
9845       {
9846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9847       };
9848     } catch (...) {
9849       {
9850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9851       };
9852     }
9853   }
9854
9855   jresult = result;
9856   return jresult;
9857 }
9858
9859
9860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9861   unsigned int jresult ;
9862   Dali::Degree *arg1 = 0 ;
9863   Dali::Degree *arg2 = 0 ;
9864   bool result;
9865
9866   arg1 = (Dali::Degree *)jarg1;
9867   if (!arg1) {
9868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9869     return 0;
9870   }
9871   arg2 = (Dali::Degree *)jarg2;
9872   if (!arg2) {
9873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9874     return 0;
9875   }
9876   {
9877     try {
9878       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9879     } catch (std::out_of_range& e) {
9880       {
9881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9882       };
9883     } catch (std::exception& e) {
9884       {
9885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9886       };
9887     } catch (Dali::DaliException e) {
9888       {
9889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9890       };
9891     } catch (...) {
9892       {
9893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9894       };
9895     }
9896   }
9897
9898   jresult = result;
9899   return jresult;
9900 }
9901
9902
9903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9904   void * jresult ;
9905   Dali::Degree arg1 ;
9906   float arg2 ;
9907   float arg3 ;
9908   Dali::Degree *argp1 ;
9909   Dali::Degree result;
9910
9911   argp1 = (Dali::Degree *)jarg1;
9912   if (!argp1) {
9913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9914     return 0;
9915   }
9916   arg1 = *argp1;
9917   arg2 = (float)jarg2;
9918   arg3 = (float)jarg3;
9919   {
9920     try {
9921       result = Dali::Clamp(arg1,arg2,arg3);
9922     } catch (std::out_of_range& e) {
9923       {
9924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9925       };
9926     } catch (std::exception& e) {
9927       {
9928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9929       };
9930     } catch (Dali::DaliException e) {
9931       {
9932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9933       };
9934     } catch (...) {
9935       {
9936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9937       };
9938     }
9939   }
9940
9941   jresult = new Dali::Degree((const Dali::Degree &)result);
9942   return jresult;
9943 }
9944
9945
9946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9947   void * jresult ;
9948   Dali::Radian *result = 0 ;
9949
9950   {
9951     try {
9952       result = (Dali::Radian *)new Dali::Radian();
9953     } catch (std::out_of_range& e) {
9954       {
9955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9956       };
9957     } catch (std::exception& e) {
9958       {
9959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9960       };
9961     } catch (Dali::DaliException e) {
9962       {
9963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9964       };
9965     } catch (...) {
9966       {
9967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9968       };
9969     }
9970   }
9971
9972   jresult = (void *)result;
9973   return jresult;
9974 }
9975
9976
9977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9978   void * jresult ;
9979   float arg1 ;
9980   Dali::Radian *result = 0 ;
9981
9982   arg1 = (float)jarg1;
9983   {
9984     try {
9985       result = (Dali::Radian *)new Dali::Radian(arg1);
9986     } catch (std::out_of_range& e) {
9987       {
9988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9989       };
9990     } catch (std::exception& e) {
9991       {
9992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9993       };
9994     } catch (Dali::DaliException e) {
9995       {
9996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9997       };
9998     } catch (...) {
9999       {
10000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10001       };
10002     }
10003   }
10004
10005   jresult = (void *)result;
10006   return jresult;
10007 }
10008
10009
10010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
10011   void * jresult ;
10012   Dali::Degree arg1 ;
10013   Dali::Degree *argp1 ;
10014   Dali::Radian *result = 0 ;
10015
10016   argp1 = (Dali::Degree *)jarg1;
10017   if (!argp1) {
10018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10019     return 0;
10020   }
10021   arg1 = *argp1;
10022   {
10023     try {
10024       result = (Dali::Radian *)new Dali::Radian(arg1);
10025     } catch (std::out_of_range& e) {
10026       {
10027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10028       };
10029     } catch (std::exception& e) {
10030       {
10031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10032       };
10033     } catch (Dali::DaliException e) {
10034       {
10035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10036       };
10037     } catch (...) {
10038       {
10039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10040       };
10041     }
10042   }
10043
10044   jresult = (void *)result;
10045   return jresult;
10046 }
10047
10048
10049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10050   void * jresult ;
10051   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10052   float arg2 ;
10053   Dali::Radian *result = 0 ;
10054
10055   arg1 = (Dali::Radian *)jarg1;
10056   arg2 = (float)jarg2;
10057   {
10058     try {
10059       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10060     } catch (std::out_of_range& e) {
10061       {
10062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10063       };
10064     } catch (std::exception& e) {
10065       {
10066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10067       };
10068     } catch (Dali::DaliException e) {
10069       {
10070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10071       };
10072     } catch (...) {
10073       {
10074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10075       };
10076     }
10077   }
10078
10079   jresult = (void *)result;
10080   return jresult;
10081 }
10082
10083
10084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10085   void * jresult ;
10086   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10087   Dali::Degree arg2 ;
10088   Dali::Degree *argp2 ;
10089   Dali::Radian *result = 0 ;
10090
10091   arg1 = (Dali::Radian *)jarg1;
10092   argp2 = (Dali::Degree *)jarg2;
10093   if (!argp2) {
10094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10095     return 0;
10096   }
10097   arg2 = *argp2;
10098   {
10099     try {
10100       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10101     } catch (std::out_of_range& e) {
10102       {
10103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10104       };
10105     } catch (std::exception& e) {
10106       {
10107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10108       };
10109     } catch (Dali::DaliException e) {
10110       {
10111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10112       };
10113     } catch (...) {
10114       {
10115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10116       };
10117     }
10118   }
10119
10120   jresult = (void *)result;
10121   return jresult;
10122 }
10123
10124
10125 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10126   float jresult ;
10127   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10128   float result;
10129
10130   arg1 = (Dali::Radian *)jarg1;
10131   {
10132     try {
10133       result = (float)((Dali::Radian const *)arg1)->operator float();
10134     } catch (std::out_of_range& e) {
10135       {
10136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10137       };
10138     } catch (std::exception& e) {
10139       {
10140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10141       };
10142     } catch (Dali::DaliException e) {
10143       {
10144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10145       };
10146     } catch (...) {
10147       {
10148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10149       };
10150     }
10151   }
10152
10153   jresult = result;
10154   return jresult;
10155 }
10156
10157
10158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10159   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10160   float arg2 ;
10161
10162   arg1 = (Dali::Radian *)jarg1;
10163   arg2 = (float)jarg2;
10164   if (arg1) (arg1)->radian = arg2;
10165 }
10166
10167
10168 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10169   float jresult ;
10170   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10171   float result;
10172
10173   arg1 = (Dali::Radian *)jarg1;
10174   result = (float) ((arg1)->radian);
10175   jresult = result;
10176   return jresult;
10177 }
10178
10179
10180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10181   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10182
10183   arg1 = (Dali::Radian *)jarg1;
10184   {
10185     try {
10186       delete arg1;
10187     } catch (std::out_of_range& e) {
10188       {
10189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10190       };
10191     } catch (std::exception& e) {
10192       {
10193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10194       };
10195     } catch (Dali::DaliException e) {
10196       {
10197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10198       };
10199     } catch (...) {
10200       {
10201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10202       };
10203     }
10204   }
10205
10206 }
10207
10208
10209 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10210   unsigned int jresult ;
10211   Dali::Radian arg1 ;
10212   Dali::Radian arg2 ;
10213   Dali::Radian *argp1 ;
10214   Dali::Radian *argp2 ;
10215   bool result;
10216
10217   argp1 = (Dali::Radian *)jarg1;
10218   if (!argp1) {
10219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10220     return 0;
10221   }
10222   arg1 = *argp1;
10223   argp2 = (Dali::Radian *)jarg2;
10224   if (!argp2) {
10225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10226     return 0;
10227   }
10228   arg2 = *argp2;
10229   {
10230     try {
10231       result = (bool)Dali::operator ==(arg1,arg2);
10232     } catch (std::out_of_range& e) {
10233       {
10234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10235       };
10236     } catch (std::exception& e) {
10237       {
10238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10239       };
10240     } catch (Dali::DaliException e) {
10241       {
10242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10243       };
10244     } catch (...) {
10245       {
10246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10247       };
10248     }
10249   }
10250
10251   jresult = result;
10252   return jresult;
10253 }
10254
10255
10256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10257   unsigned int jresult ;
10258   Dali::Radian arg1 ;
10259   Dali::Radian arg2 ;
10260   Dali::Radian *argp1 ;
10261   Dali::Radian *argp2 ;
10262   bool result;
10263
10264   argp1 = (Dali::Radian *)jarg1;
10265   if (!argp1) {
10266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10267     return 0;
10268   }
10269   arg1 = *argp1;
10270   argp2 = (Dali::Radian *)jarg2;
10271   if (!argp2) {
10272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10273     return 0;
10274   }
10275   arg2 = *argp2;
10276   {
10277     try {
10278       result = (bool)Dali::operator !=(arg1,arg2);
10279     } catch (std::out_of_range& e) {
10280       {
10281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10282       };
10283     } catch (std::exception& e) {
10284       {
10285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10286       };
10287     } catch (Dali::DaliException e) {
10288       {
10289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10290       };
10291     } catch (...) {
10292       {
10293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10294       };
10295     }
10296   }
10297
10298   jresult = result;
10299   return jresult;
10300 }
10301
10302
10303 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10304   unsigned int jresult ;
10305   Dali::Radian arg1 ;
10306   Dali::Degree arg2 ;
10307   Dali::Radian *argp1 ;
10308   Dali::Degree *argp2 ;
10309   bool result;
10310
10311   argp1 = (Dali::Radian *)jarg1;
10312   if (!argp1) {
10313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10314     return 0;
10315   }
10316   arg1 = *argp1;
10317   argp2 = (Dali::Degree *)jarg2;
10318   if (!argp2) {
10319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10320     return 0;
10321   }
10322   arg2 = *argp2;
10323   {
10324     try {
10325       result = (bool)Dali::operator ==(arg1,arg2);
10326     } catch (std::out_of_range& e) {
10327       {
10328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10329       };
10330     } catch (std::exception& e) {
10331       {
10332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10333       };
10334     } catch (Dali::DaliException e) {
10335       {
10336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10337       };
10338     } catch (...) {
10339       {
10340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10341       };
10342     }
10343   }
10344
10345   jresult = result;
10346   return jresult;
10347 }
10348
10349
10350 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10351   unsigned int jresult ;
10352   Dali::Radian arg1 ;
10353   Dali::Degree arg2 ;
10354   Dali::Radian *argp1 ;
10355   Dali::Degree *argp2 ;
10356   bool result;
10357
10358   argp1 = (Dali::Radian *)jarg1;
10359   if (!argp1) {
10360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10361     return 0;
10362   }
10363   arg1 = *argp1;
10364   argp2 = (Dali::Degree *)jarg2;
10365   if (!argp2) {
10366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10367     return 0;
10368   }
10369   arg2 = *argp2;
10370   {
10371     try {
10372       result = (bool)Dali::operator !=(arg1,arg2);
10373     } catch (std::out_of_range& e) {
10374       {
10375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10376       };
10377     } catch (std::exception& e) {
10378       {
10379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10380       };
10381     } catch (Dali::DaliException e) {
10382       {
10383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10384       };
10385     } catch (...) {
10386       {
10387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10388       };
10389     }
10390   }
10391
10392   jresult = result;
10393   return jresult;
10394 }
10395
10396
10397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10398   unsigned int jresult ;
10399   Dali::Degree arg1 ;
10400   Dali::Radian arg2 ;
10401   Dali::Degree *argp1 ;
10402   Dali::Radian *argp2 ;
10403   bool result;
10404
10405   argp1 = (Dali::Degree *)jarg1;
10406   if (!argp1) {
10407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10408     return 0;
10409   }
10410   arg1 = *argp1;
10411   argp2 = (Dali::Radian *)jarg2;
10412   if (!argp2) {
10413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10414     return 0;
10415   }
10416   arg2 = *argp2;
10417   {
10418     try {
10419       result = (bool)Dali::operator ==(arg1,arg2);
10420     } catch (std::out_of_range& e) {
10421       {
10422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10423       };
10424     } catch (std::exception& e) {
10425       {
10426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10427       };
10428     } catch (Dali::DaliException e) {
10429       {
10430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10431       };
10432     } catch (...) {
10433       {
10434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10435       };
10436     }
10437   }
10438
10439   jresult = result;
10440   return jresult;
10441 }
10442
10443
10444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10445   unsigned int jresult ;
10446   Dali::Degree arg1 ;
10447   Dali::Radian arg2 ;
10448   Dali::Degree *argp1 ;
10449   Dali::Radian *argp2 ;
10450   bool result;
10451
10452   argp1 = (Dali::Degree *)jarg1;
10453   if (!argp1) {
10454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10455     return 0;
10456   }
10457   arg1 = *argp1;
10458   argp2 = (Dali::Radian *)jarg2;
10459   if (!argp2) {
10460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10461     return 0;
10462   }
10463   arg2 = *argp2;
10464   {
10465     try {
10466       result = (bool)Dali::operator !=(arg1,arg2);
10467     } catch (std::out_of_range& e) {
10468       {
10469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10470       };
10471     } catch (std::exception& e) {
10472       {
10473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10474       };
10475     } catch (Dali::DaliException e) {
10476       {
10477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10478       };
10479     } catch (...) {
10480       {
10481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10482       };
10483     }
10484   }
10485
10486   jresult = result;
10487   return jresult;
10488 }
10489
10490
10491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10492   unsigned int jresult ;
10493   Dali::Radian arg1 ;
10494   Dali::Radian arg2 ;
10495   Dali::Radian *argp1 ;
10496   Dali::Radian *argp2 ;
10497   bool result;
10498
10499   argp1 = (Dali::Radian *)jarg1;
10500   if (!argp1) {
10501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10502     return 0;
10503   }
10504   arg1 = *argp1;
10505   argp2 = (Dali::Radian *)jarg2;
10506   if (!argp2) {
10507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10508     return 0;
10509   }
10510   arg2 = *argp2;
10511   {
10512     try {
10513       result = (bool)Dali::operator >(arg1,arg2);
10514     } catch (std::out_of_range& e) {
10515       {
10516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10517       };
10518     } catch (std::exception& e) {
10519       {
10520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10521       };
10522     } catch (Dali::DaliException e) {
10523       {
10524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10525       };
10526     } catch (...) {
10527       {
10528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10529       };
10530     }
10531   }
10532
10533   jresult = result;
10534   return jresult;
10535 }
10536
10537
10538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10539   unsigned int jresult ;
10540   Dali::Radian arg1 ;
10541   Dali::Degree arg2 ;
10542   Dali::Radian *argp1 ;
10543   Dali::Degree *argp2 ;
10544   bool result;
10545
10546   argp1 = (Dali::Radian *)jarg1;
10547   if (!argp1) {
10548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10549     return 0;
10550   }
10551   arg1 = *argp1;
10552   argp2 = (Dali::Degree *)jarg2;
10553   if (!argp2) {
10554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10555     return 0;
10556   }
10557   arg2 = *argp2;
10558   {
10559     try {
10560       result = (bool)Dali::operator >(arg1,arg2);
10561     } catch (std::out_of_range& e) {
10562       {
10563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10564       };
10565     } catch (std::exception& e) {
10566       {
10567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10568       };
10569     } catch (Dali::DaliException e) {
10570       {
10571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10572       };
10573     } catch (...) {
10574       {
10575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10576       };
10577     }
10578   }
10579
10580   jresult = result;
10581   return jresult;
10582 }
10583
10584
10585 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10586   unsigned int jresult ;
10587   Dali::Degree arg1 ;
10588   Dali::Radian arg2 ;
10589   Dali::Degree *argp1 ;
10590   Dali::Radian *argp2 ;
10591   bool result;
10592
10593   argp1 = (Dali::Degree *)jarg1;
10594   if (!argp1) {
10595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10596     return 0;
10597   }
10598   arg1 = *argp1;
10599   argp2 = (Dali::Radian *)jarg2;
10600   if (!argp2) {
10601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10602     return 0;
10603   }
10604   arg2 = *argp2;
10605   {
10606     try {
10607       result = (bool)Dali::operator >(arg1,arg2);
10608     } catch (std::out_of_range& e) {
10609       {
10610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10611       };
10612     } catch (std::exception& e) {
10613       {
10614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10615       };
10616     } catch (Dali::DaliException e) {
10617       {
10618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10619       };
10620     } catch (...) {
10621       {
10622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10623       };
10624     }
10625   }
10626
10627   jresult = result;
10628   return jresult;
10629 }
10630
10631
10632 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10633   unsigned int jresult ;
10634   Dali::Radian arg1 ;
10635   Dali::Radian arg2 ;
10636   Dali::Radian *argp1 ;
10637   Dali::Radian *argp2 ;
10638   bool result;
10639
10640   argp1 = (Dali::Radian *)jarg1;
10641   if (!argp1) {
10642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10643     return 0;
10644   }
10645   arg1 = *argp1;
10646   argp2 = (Dali::Radian *)jarg2;
10647   if (!argp2) {
10648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10649     return 0;
10650   }
10651   arg2 = *argp2;
10652   {
10653     try {
10654       result = (bool)Dali::operator <(arg1,arg2);
10655     } catch (std::out_of_range& e) {
10656       {
10657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10658       };
10659     } catch (std::exception& e) {
10660       {
10661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10662       };
10663     } catch (Dali::DaliException e) {
10664       {
10665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10666       };
10667     } catch (...) {
10668       {
10669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10670       };
10671     }
10672   }
10673
10674   jresult = result;
10675   return jresult;
10676 }
10677
10678
10679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10680   unsigned int jresult ;
10681   Dali::Radian arg1 ;
10682   Dali::Degree arg2 ;
10683   Dali::Radian *argp1 ;
10684   Dali::Degree *argp2 ;
10685   bool result;
10686
10687   argp1 = (Dali::Radian *)jarg1;
10688   if (!argp1) {
10689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10690     return 0;
10691   }
10692   arg1 = *argp1;
10693   argp2 = (Dali::Degree *)jarg2;
10694   if (!argp2) {
10695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10696     return 0;
10697   }
10698   arg2 = *argp2;
10699   {
10700     try {
10701       result = (bool)Dali::operator <(arg1,arg2);
10702     } catch (std::out_of_range& e) {
10703       {
10704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10705       };
10706     } catch (std::exception& e) {
10707       {
10708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10709       };
10710     } catch (Dali::DaliException e) {
10711       {
10712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10713       };
10714     } catch (...) {
10715       {
10716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10717       };
10718     }
10719   }
10720
10721   jresult = result;
10722   return jresult;
10723 }
10724
10725
10726 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10727   unsigned int jresult ;
10728   Dali::Degree arg1 ;
10729   Dali::Radian arg2 ;
10730   Dali::Degree *argp1 ;
10731   Dali::Radian *argp2 ;
10732   bool result;
10733
10734   argp1 = (Dali::Degree *)jarg1;
10735   if (!argp1) {
10736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10737     return 0;
10738   }
10739   arg1 = *argp1;
10740   argp2 = (Dali::Radian *)jarg2;
10741   if (!argp2) {
10742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10743     return 0;
10744   }
10745   arg2 = *argp2;
10746   {
10747     try {
10748       result = (bool)Dali::operator <(arg1,arg2);
10749     } catch (std::out_of_range& e) {
10750       {
10751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10752       };
10753     } catch (std::exception& e) {
10754       {
10755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10756       };
10757     } catch (Dali::DaliException e) {
10758       {
10759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10760       };
10761     } catch (...) {
10762       {
10763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10764       };
10765     }
10766   }
10767
10768   jresult = result;
10769   return jresult;
10770 }
10771
10772
10773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10774   void * jresult ;
10775   Dali::Radian arg1 ;
10776   float arg2 ;
10777   Dali::Radian *argp1 ;
10778   Dali::Radian result;
10779
10780   argp1 = (Dali::Radian *)jarg1;
10781   if (!argp1) {
10782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10783     return 0;
10784   }
10785   arg1 = *argp1;
10786   arg2 = (float)jarg2;
10787   {
10788     try {
10789       result = Dali::operator *(arg1,arg2);
10790     } catch (std::out_of_range& e) {
10791       {
10792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10793       };
10794     } catch (std::exception& e) {
10795       {
10796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10797       };
10798     } catch (Dali::DaliException e) {
10799       {
10800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10801       };
10802     } catch (...) {
10803       {
10804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10805       };
10806     }
10807   }
10808
10809   jresult = new Dali::Radian((const Dali::Radian &)result);
10810   return jresult;
10811 }
10812
10813
10814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10815   void * jresult ;
10816   Dali::Radian arg1 ;
10817   Dali::Radian *argp1 ;
10818   Dali::Radian result;
10819
10820   argp1 = (Dali::Radian *)jarg1;
10821   if (!argp1) {
10822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10823     return 0;
10824   }
10825   arg1 = *argp1;
10826   {
10827     try {
10828       result = Dali::operator -(arg1);
10829     } catch (std::out_of_range& e) {
10830       {
10831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10832       };
10833     } catch (std::exception& e) {
10834       {
10835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10836       };
10837     } catch (Dali::DaliException e) {
10838       {
10839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10840       };
10841     } catch (...) {
10842       {
10843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10844       };
10845     }
10846   }
10847
10848   jresult = new Dali::Radian((const Dali::Radian &)result);
10849   return jresult;
10850 }
10851
10852
10853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10854   void * jresult ;
10855   Dali::Radian arg1 ;
10856   float arg2 ;
10857   float arg3 ;
10858   Dali::Radian *argp1 ;
10859   Dali::Radian result;
10860
10861   argp1 = (Dali::Radian *)jarg1;
10862   if (!argp1) {
10863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10864     return 0;
10865   }
10866   arg1 = *argp1;
10867   arg2 = (float)jarg2;
10868   arg3 = (float)jarg3;
10869   {
10870     try {
10871       result = Dali::Clamp(arg1,arg2,arg3);
10872     } catch (std::out_of_range& e) {
10873       {
10874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10875       };
10876     } catch (std::exception& e) {
10877       {
10878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10879       };
10880     } catch (Dali::DaliException e) {
10881       {
10882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10883       };
10884     } catch (...) {
10885       {
10886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10887       };
10888     }
10889   }
10890
10891   jresult = new Dali::Radian((const Dali::Radian &)result);
10892   return jresult;
10893 }
10894
10895
10896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10897   void * jresult ;
10898   Dali::Quaternion *result = 0 ;
10899
10900   {
10901     try {
10902       result = (Dali::Quaternion *)new Dali::Quaternion();
10903     } catch (std::out_of_range& e) {
10904       {
10905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10906       };
10907     } catch (std::exception& e) {
10908       {
10909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10910       };
10911     } catch (Dali::DaliException e) {
10912       {
10913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10914       };
10915     } catch (...) {
10916       {
10917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10918       };
10919     }
10920   }
10921
10922   jresult = (void *)result;
10923   return jresult;
10924 }
10925
10926
10927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10928   void * jresult ;
10929   Dali::Radian arg1 ;
10930   Dali::Vector3 *arg2 = 0 ;
10931   Dali::Radian *argp1 ;
10932   Dali::Quaternion *result = 0 ;
10933
10934   argp1 = (Dali::Radian *)jarg1;
10935   if (!argp1) {
10936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10937     return 0;
10938   }
10939   arg1 = *argp1;
10940   arg2 = (Dali::Vector3 *)jarg2;
10941   if (!arg2) {
10942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10943     return 0;
10944   }
10945   {
10946     try {
10947       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10948     } catch (std::out_of_range& e) {
10949       {
10950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10951       };
10952     } catch (std::exception& e) {
10953       {
10954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10955       };
10956     } catch (Dali::DaliException e) {
10957       {
10958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10959       };
10960     } catch (...) {
10961       {
10962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10963       };
10964     }
10965   }
10966
10967   jresult = (void *)result;
10968   return jresult;
10969 }
10970
10971
10972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10973   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10974
10975   arg1 = (Dali::Quaternion *)jarg1;
10976   {
10977     try {
10978       delete arg1;
10979     } catch (std::out_of_range& e) {
10980       {
10981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10982       };
10983     } catch (std::exception& e) {
10984       {
10985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10986       };
10987     } catch (Dali::DaliException e) {
10988       {
10989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10990       };
10991     } catch (...) {
10992       {
10993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10994       };
10995     }
10996   }
10997
10998 }
10999
11000
11001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
11002   void * jresult ;
11003   Dali::Quaternion *result = 0 ;
11004
11005   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
11006   jresult = (void *)result;
11007   return jresult;
11008 }
11009
11010
11011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
11012   unsigned int jresult ;
11013   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11014   bool result;
11015
11016   arg1 = (Dali::Quaternion *)jarg1;
11017   {
11018     try {
11019       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
11020     } catch (std::out_of_range& e) {
11021       {
11022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11023       };
11024     } catch (std::exception& e) {
11025       {
11026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11027       };
11028     } catch (Dali::DaliException e) {
11029       {
11030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11031       };
11032     } catch (...) {
11033       {
11034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11035       };
11036     }
11037   }
11038
11039   jresult = result;
11040   return jresult;
11041 }
11042
11043
11044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
11045   unsigned int jresult ;
11046   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11047   Dali::Vector3 *arg2 = 0 ;
11048   Dali::Radian *arg3 = 0 ;
11049   bool result;
11050
11051   arg1 = (Dali::Quaternion *)jarg1;
11052   arg2 = (Dali::Vector3 *)jarg2;
11053   if (!arg2) {
11054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11055     return 0;
11056   }
11057   arg3 = (Dali::Radian *)jarg3;
11058   if (!arg3) {
11059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11060     return 0;
11061   }
11062   {
11063     try {
11064       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11065     } catch (std::out_of_range& e) {
11066       {
11067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11068       };
11069     } catch (std::exception& e) {
11070       {
11071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11072       };
11073     } catch (Dali::DaliException e) {
11074       {
11075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11076       };
11077     } catch (...) {
11078       {
11079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11080       };
11081     }
11082   }
11083
11084   jresult = result;
11085   return jresult;
11086 }
11087
11088
11089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11090   void * jresult ;
11091   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11092   Dali::Quaternion *arg2 = 0 ;
11093   Dali::Quaternion result;
11094
11095   arg1 = (Dali::Quaternion *)jarg1;
11096   arg2 = (Dali::Quaternion *)jarg2;
11097   if (!arg2) {
11098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11099     return 0;
11100   }
11101   {
11102     try {
11103       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11104     } catch (std::out_of_range& e) {
11105       {
11106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11107       };
11108     } catch (std::exception& e) {
11109       {
11110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11111       };
11112     } catch (Dali::DaliException e) {
11113       {
11114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11115       };
11116     } catch (...) {
11117       {
11118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11119       };
11120     }
11121   }
11122
11123   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11124   return jresult;
11125 }
11126
11127
11128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11129   void * jresult ;
11130   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11131   Dali::Quaternion *arg2 = 0 ;
11132   Dali::Quaternion result;
11133
11134   arg1 = (Dali::Quaternion *)jarg1;
11135   arg2 = (Dali::Quaternion *)jarg2;
11136   if (!arg2) {
11137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11138     return 0;
11139   }
11140   {
11141     try {
11142       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11143     } catch (std::out_of_range& e) {
11144       {
11145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11146       };
11147     } catch (std::exception& e) {
11148       {
11149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11150       };
11151     } catch (Dali::DaliException e) {
11152       {
11153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11154       };
11155     } catch (...) {
11156       {
11157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11158       };
11159     }
11160   }
11161
11162   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11163   return jresult;
11164 }
11165
11166
11167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11168   void * jresult ;
11169   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11170   Dali::Quaternion *arg2 = 0 ;
11171   Dali::Quaternion result;
11172
11173   arg1 = (Dali::Quaternion *)jarg1;
11174   arg2 = (Dali::Quaternion *)jarg2;
11175   if (!arg2) {
11176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11177     return 0;
11178   }
11179   {
11180     try {
11181       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11182     } catch (std::out_of_range& e) {
11183       {
11184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11185       };
11186     } catch (std::exception& e) {
11187       {
11188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11189       };
11190     } catch (Dali::DaliException e) {
11191       {
11192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11193       };
11194     } catch (...) {
11195       {
11196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11197       };
11198     }
11199   }
11200
11201   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11202   return jresult;
11203 }
11204
11205
11206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11207   void * jresult ;
11208   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11209   Dali::Vector3 *arg2 = 0 ;
11210   Dali::Vector3 result;
11211
11212   arg1 = (Dali::Quaternion *)jarg1;
11213   arg2 = (Dali::Vector3 *)jarg2;
11214   if (!arg2) {
11215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11216     return 0;
11217   }
11218   {
11219     try {
11220       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11221     } catch (std::out_of_range& e) {
11222       {
11223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11224       };
11225     } catch (std::exception& e) {
11226       {
11227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11228       };
11229     } catch (Dali::DaliException e) {
11230       {
11231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11232       };
11233     } catch (...) {
11234       {
11235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11236       };
11237     }
11238   }
11239
11240   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11241   return jresult;
11242 }
11243
11244
11245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11246   void * jresult ;
11247   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11248   Dali::Quaternion *arg2 = 0 ;
11249   Dali::Quaternion result;
11250
11251   arg1 = (Dali::Quaternion *)jarg1;
11252   arg2 = (Dali::Quaternion *)jarg2;
11253   if (!arg2) {
11254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11255     return 0;
11256   }
11257   {
11258     try {
11259       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11260     } catch (std::out_of_range& e) {
11261       {
11262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11263       };
11264     } catch (std::exception& e) {
11265       {
11266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11267       };
11268     } catch (Dali::DaliException e) {
11269       {
11270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11271       };
11272     } catch (...) {
11273       {
11274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11275       };
11276     }
11277   }
11278
11279   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11280   return jresult;
11281 }
11282
11283
11284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11285   void * jresult ;
11286   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11287   float arg2 ;
11288   Dali::Quaternion result;
11289
11290   arg1 = (Dali::Quaternion *)jarg1;
11291   arg2 = (float)jarg2;
11292   {
11293     try {
11294       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11295     } catch (std::out_of_range& e) {
11296       {
11297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11298       };
11299     } catch (std::exception& e) {
11300       {
11301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11302       };
11303     } catch (Dali::DaliException e) {
11304       {
11305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11306       };
11307     } catch (...) {
11308       {
11309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11310       };
11311     }
11312   }
11313
11314   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11315   return jresult;
11316 }
11317
11318
11319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11320   void * jresult ;
11321   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11322   float arg2 ;
11323   Dali::Quaternion result;
11324
11325   arg1 = (Dali::Quaternion *)jarg1;
11326   arg2 = (float)jarg2;
11327   {
11328     try {
11329       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11330     } catch (std::out_of_range& e) {
11331       {
11332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11333       };
11334     } catch (std::exception& e) {
11335       {
11336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11337       };
11338     } catch (Dali::DaliException e) {
11339       {
11340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11341       };
11342     } catch (...) {
11343       {
11344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11345       };
11346     }
11347   }
11348
11349   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11350   return jresult;
11351 }
11352
11353
11354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11355   void * jresult ;
11356   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11357   Dali::Quaternion result;
11358
11359   arg1 = (Dali::Quaternion *)jarg1;
11360   {
11361     try {
11362       result = ((Dali::Quaternion const *)arg1)->operator -();
11363     } catch (std::out_of_range& e) {
11364       {
11365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11366       };
11367     } catch (std::exception& e) {
11368       {
11369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11370       };
11371     } catch (Dali::DaliException e) {
11372       {
11373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11374       };
11375     } catch (...) {
11376       {
11377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11378       };
11379     }
11380   }
11381
11382   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11383   return jresult;
11384 }
11385
11386
11387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11388   void * jresult ;
11389   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11390   Dali::Quaternion *arg2 = 0 ;
11391   Dali::Quaternion *result = 0 ;
11392
11393   arg1 = (Dali::Quaternion *)jarg1;
11394   arg2 = (Dali::Quaternion *)jarg2;
11395   if (!arg2) {
11396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11397     return 0;
11398   }
11399   {
11400     try {
11401       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11402     } catch (std::out_of_range& e) {
11403       {
11404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11405       };
11406     } catch (std::exception& e) {
11407       {
11408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11409       };
11410     } catch (Dali::DaliException e) {
11411       {
11412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11413       };
11414     } catch (...) {
11415       {
11416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11417       };
11418     }
11419   }
11420
11421   jresult = (void *)result;
11422   return jresult;
11423 }
11424
11425
11426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11427   void * jresult ;
11428   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11429   Dali::Quaternion *arg2 = 0 ;
11430   Dali::Quaternion *result = 0 ;
11431
11432   arg1 = (Dali::Quaternion *)jarg1;
11433   arg2 = (Dali::Quaternion *)jarg2;
11434   if (!arg2) {
11435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11436     return 0;
11437   }
11438   {
11439     try {
11440       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11441     } catch (std::out_of_range& e) {
11442       {
11443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11444       };
11445     } catch (std::exception& e) {
11446       {
11447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11448       };
11449     } catch (Dali::DaliException e) {
11450       {
11451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11452       };
11453     } catch (...) {
11454       {
11455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11456       };
11457     }
11458   }
11459
11460   jresult = (void *)result;
11461   return jresult;
11462 }
11463
11464
11465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11466   void * jresult ;
11467   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11468   Dali::Quaternion *arg2 = 0 ;
11469   Dali::Quaternion *result = 0 ;
11470
11471   arg1 = (Dali::Quaternion *)jarg1;
11472   arg2 = (Dali::Quaternion *)jarg2;
11473   if (!arg2) {
11474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11475     return 0;
11476   }
11477   {
11478     try {
11479       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11480     } catch (std::out_of_range& e) {
11481       {
11482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11483       };
11484     } catch (std::exception& e) {
11485       {
11486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11487       };
11488     } catch (Dali::DaliException e) {
11489       {
11490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11491       };
11492     } catch (...) {
11493       {
11494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11495       };
11496     }
11497   }
11498
11499   jresult = (void *)result;
11500   return jresult;
11501 }
11502
11503
11504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11505   void * jresult ;
11506   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11507   float arg2 ;
11508   Dali::Quaternion *result = 0 ;
11509
11510   arg1 = (Dali::Quaternion *)jarg1;
11511   arg2 = (float)jarg2;
11512   {
11513     try {
11514       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11515     } catch (std::out_of_range& e) {
11516       {
11517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11518       };
11519     } catch (std::exception& e) {
11520       {
11521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11522       };
11523     } catch (Dali::DaliException e) {
11524       {
11525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11526       };
11527     } catch (...) {
11528       {
11529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11530       };
11531     }
11532   }
11533
11534   jresult = (void *)result;
11535   return jresult;
11536 }
11537
11538
11539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11540   void * jresult ;
11541   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11542   float arg2 ;
11543   Dali::Quaternion *result = 0 ;
11544
11545   arg1 = (Dali::Quaternion *)jarg1;
11546   arg2 = (float)jarg2;
11547   {
11548     try {
11549       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11550     } catch (std::out_of_range& e) {
11551       {
11552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11553       };
11554     } catch (std::exception& e) {
11555       {
11556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11557       };
11558     } catch (Dali::DaliException e) {
11559       {
11560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11561       };
11562     } catch (...) {
11563       {
11564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11565       };
11566     }
11567   }
11568
11569   jresult = (void *)result;
11570   return jresult;
11571 }
11572
11573
11574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11575   unsigned int jresult ;
11576   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11577   Dali::Quaternion *arg2 = 0 ;
11578   bool result;
11579
11580   arg1 = (Dali::Quaternion *)jarg1;
11581   arg2 = (Dali::Quaternion *)jarg2;
11582   if (!arg2) {
11583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11584     return 0;
11585   }
11586   {
11587     try {
11588       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11589     } catch (std::out_of_range& e) {
11590       {
11591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11592       };
11593     } catch (std::exception& e) {
11594       {
11595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11596       };
11597     } catch (Dali::DaliException e) {
11598       {
11599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11600       };
11601     } catch (...) {
11602       {
11603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11604       };
11605     }
11606   }
11607
11608   jresult = result;
11609   return jresult;
11610 }
11611
11612
11613 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11614   unsigned int jresult ;
11615   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11616   Dali::Quaternion *arg2 = 0 ;
11617   bool result;
11618
11619   arg1 = (Dali::Quaternion *)jarg1;
11620   arg2 = (Dali::Quaternion *)jarg2;
11621   if (!arg2) {
11622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11623     return 0;
11624   }
11625   {
11626     try {
11627       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11628     } catch (std::out_of_range& e) {
11629       {
11630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11631       };
11632     } catch (std::exception& e) {
11633       {
11634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11635       };
11636     } catch (Dali::DaliException e) {
11637       {
11638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11639       };
11640     } catch (...) {
11641       {
11642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11643       };
11644     }
11645   }
11646
11647   jresult = result;
11648   return jresult;
11649 }
11650
11651
11652 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11653   float jresult ;
11654   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11655   float result;
11656
11657   arg1 = (Dali::Quaternion *)jarg1;
11658   {
11659     try {
11660       result = (float)((Dali::Quaternion const *)arg1)->Length();
11661     } catch (std::out_of_range& e) {
11662       {
11663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11664       };
11665     } catch (std::exception& e) {
11666       {
11667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11668       };
11669     } catch (Dali::DaliException e) {
11670       {
11671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11672       };
11673     } catch (...) {
11674       {
11675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11676       };
11677     }
11678   }
11679
11680   jresult = result;
11681   return jresult;
11682 }
11683
11684
11685 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11686   float jresult ;
11687   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11688   float result;
11689
11690   arg1 = (Dali::Quaternion *)jarg1;
11691   {
11692     try {
11693       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11694     } catch (std::out_of_range& e) {
11695       {
11696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11697       };
11698     } catch (std::exception& e) {
11699       {
11700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11701       };
11702     } catch (Dali::DaliException e) {
11703       {
11704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11705       };
11706     } catch (...) {
11707       {
11708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11709       };
11710     }
11711   }
11712
11713   jresult = result;
11714   return jresult;
11715 }
11716
11717
11718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11719   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11720
11721   arg1 = (Dali::Quaternion *)jarg1;
11722   {
11723     try {
11724       (arg1)->Normalize();
11725     } catch (std::out_of_range& e) {
11726       {
11727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11728       };
11729     } catch (std::exception& e) {
11730       {
11731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11732       };
11733     } catch (Dali::DaliException e) {
11734       {
11735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11736       };
11737     } catch (...) {
11738       {
11739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11740       };
11741     }
11742   }
11743
11744 }
11745
11746
11747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11748   void * jresult ;
11749   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11750   Dali::Quaternion result;
11751
11752   arg1 = (Dali::Quaternion *)jarg1;
11753   {
11754     try {
11755       result = ((Dali::Quaternion const *)arg1)->Normalized();
11756     } catch (std::out_of_range& e) {
11757       {
11758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11759       };
11760     } catch (std::exception& e) {
11761       {
11762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11763       };
11764     } catch (Dali::DaliException e) {
11765       {
11766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11767       };
11768     } catch (...) {
11769       {
11770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11771       };
11772     }
11773   }
11774
11775   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11776   return jresult;
11777 }
11778
11779
11780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11781   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11782
11783   arg1 = (Dali::Quaternion *)jarg1;
11784   {
11785     try {
11786       (arg1)->Conjugate();
11787     } catch (std::out_of_range& e) {
11788       {
11789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11790       };
11791     } catch (std::exception& e) {
11792       {
11793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11794       };
11795     } catch (Dali::DaliException e) {
11796       {
11797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11798       };
11799     } catch (...) {
11800       {
11801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11802       };
11803     }
11804   }
11805
11806 }
11807
11808
11809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11810   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11811
11812   arg1 = (Dali::Quaternion *)jarg1;
11813   {
11814     try {
11815       (arg1)->Invert();
11816     } catch (std::out_of_range& e) {
11817       {
11818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11819       };
11820     } catch (std::exception& e) {
11821       {
11822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11823       };
11824     } catch (Dali::DaliException e) {
11825       {
11826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11827       };
11828     } catch (...) {
11829       {
11830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11831       };
11832     }
11833   }
11834
11835 }
11836
11837
11838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11839   void * jresult ;
11840   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11841   Dali::Quaternion result;
11842
11843   arg1 = (Dali::Quaternion *)jarg1;
11844   {
11845     try {
11846       result = ((Dali::Quaternion const *)arg1)->Log();
11847     } catch (std::out_of_range& e) {
11848       {
11849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11850       };
11851     } catch (std::exception& e) {
11852       {
11853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11854       };
11855     } catch (Dali::DaliException e) {
11856       {
11857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11858       };
11859     } catch (...) {
11860       {
11861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11862       };
11863     }
11864   }
11865
11866   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11867   return jresult;
11868 }
11869
11870
11871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11872   void * jresult ;
11873   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11874   Dali::Quaternion result;
11875
11876   arg1 = (Dali::Quaternion *)jarg1;
11877   {
11878     try {
11879       result = ((Dali::Quaternion const *)arg1)->Exp();
11880     } catch (std::out_of_range& e) {
11881       {
11882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11883       };
11884     } catch (std::exception& e) {
11885       {
11886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11887       };
11888     } catch (Dali::DaliException e) {
11889       {
11890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11891       };
11892     } catch (...) {
11893       {
11894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11895       };
11896     }
11897   }
11898
11899   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11900   return jresult;
11901 }
11902
11903
11904 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11905   float jresult ;
11906   Dali::Quaternion *arg1 = 0 ;
11907   Dali::Quaternion *arg2 = 0 ;
11908   float result;
11909
11910   arg1 = (Dali::Quaternion *)jarg1;
11911   if (!arg1) {
11912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11913     return 0;
11914   }
11915   arg2 = (Dali::Quaternion *)jarg2;
11916   if (!arg2) {
11917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11918     return 0;
11919   }
11920   {
11921     try {
11922       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11923     } catch (std::out_of_range& e) {
11924       {
11925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11926       };
11927     } catch (std::exception& e) {
11928       {
11929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11930       };
11931     } catch (Dali::DaliException e) {
11932       {
11933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11934       };
11935     } catch (...) {
11936       {
11937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11938       };
11939     }
11940   }
11941
11942   jresult = result;
11943   return jresult;
11944 }
11945
11946
11947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11948   void * jresult ;
11949   Dali::Quaternion *arg1 = 0 ;
11950   Dali::Quaternion *arg2 = 0 ;
11951   float arg3 ;
11952   Dali::Quaternion result;
11953
11954   arg1 = (Dali::Quaternion *)jarg1;
11955   if (!arg1) {
11956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11957     return 0;
11958   }
11959   arg2 = (Dali::Quaternion *)jarg2;
11960   if (!arg2) {
11961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11962     return 0;
11963   }
11964   arg3 = (float)jarg3;
11965   {
11966     try {
11967       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11968     } catch (std::out_of_range& e) {
11969       {
11970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11971       };
11972     } catch (std::exception& e) {
11973       {
11974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11975       };
11976     } catch (Dali::DaliException e) {
11977       {
11978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11979       };
11980     } catch (...) {
11981       {
11982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11983       };
11984     }
11985   }
11986
11987   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11988   return jresult;
11989 }
11990
11991
11992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11993   void * jresult ;
11994   Dali::Quaternion *arg1 = 0 ;
11995   Dali::Quaternion *arg2 = 0 ;
11996   float arg3 ;
11997   Dali::Quaternion result;
11998
11999   arg1 = (Dali::Quaternion *)jarg1;
12000   if (!arg1) {
12001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12002     return 0;
12003   }
12004   arg2 = (Dali::Quaternion *)jarg2;
12005   if (!arg2) {
12006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12007     return 0;
12008   }
12009   arg3 = (float)jarg3;
12010   {
12011     try {
12012       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12013     } catch (std::out_of_range& e) {
12014       {
12015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12016       };
12017     } catch (std::exception& e) {
12018       {
12019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12020       };
12021     } catch (Dali::DaliException e) {
12022       {
12023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12024       };
12025     } catch (...) {
12026       {
12027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12028       };
12029     }
12030   }
12031
12032   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12033   return jresult;
12034 }
12035
12036
12037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
12038   void * jresult ;
12039   Dali::Quaternion *arg1 = 0 ;
12040   Dali::Quaternion *arg2 = 0 ;
12041   float arg3 ;
12042   Dali::Quaternion result;
12043
12044   arg1 = (Dali::Quaternion *)jarg1;
12045   if (!arg1) {
12046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12047     return 0;
12048   }
12049   arg2 = (Dali::Quaternion *)jarg2;
12050   if (!arg2) {
12051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12052     return 0;
12053   }
12054   arg3 = (float)jarg3;
12055   {
12056     try {
12057       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12058     } catch (std::out_of_range& e) {
12059       {
12060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12061       };
12062     } catch (std::exception& e) {
12063       {
12064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12065       };
12066     } catch (Dali::DaliException e) {
12067       {
12068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12069       };
12070     } catch (...) {
12071       {
12072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12073       };
12074     }
12075   }
12076
12077   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12078   return jresult;
12079 }
12080
12081
12082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12083   void * jresult ;
12084   Dali::Quaternion *arg1 = 0 ;
12085   Dali::Quaternion *arg2 = 0 ;
12086   Dali::Quaternion *arg3 = 0 ;
12087   Dali::Quaternion *arg4 = 0 ;
12088   float arg5 ;
12089   Dali::Quaternion result;
12090
12091   arg1 = (Dali::Quaternion *)jarg1;
12092   if (!arg1) {
12093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12094     return 0;
12095   }
12096   arg2 = (Dali::Quaternion *)jarg2;
12097   if (!arg2) {
12098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12099     return 0;
12100   }
12101   arg3 = (Dali::Quaternion *)jarg3;
12102   if (!arg3) {
12103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12104     return 0;
12105   }
12106   arg4 = (Dali::Quaternion *)jarg4;
12107   if (!arg4) {
12108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12109     return 0;
12110   }
12111   arg5 = (float)jarg5;
12112   {
12113     try {
12114       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12115     } catch (std::out_of_range& e) {
12116       {
12117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12118       };
12119     } catch (std::exception& e) {
12120       {
12121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12122       };
12123     } catch (Dali::DaliException e) {
12124       {
12125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12126       };
12127     } catch (...) {
12128       {
12129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12130       };
12131     }
12132   }
12133
12134   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12135   return jresult;
12136 }
12137
12138
12139 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12140   float jresult ;
12141   Dali::Quaternion *arg1 = 0 ;
12142   Dali::Quaternion *arg2 = 0 ;
12143   float result;
12144
12145   arg1 = (Dali::Quaternion *)jarg1;
12146   if (!arg1) {
12147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12148     return 0;
12149   }
12150   arg2 = (Dali::Quaternion *)jarg2;
12151   if (!arg2) {
12152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12153     return 0;
12154   }
12155   {
12156     try {
12157       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12158     } catch (std::out_of_range& e) {
12159       {
12160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12161       };
12162     } catch (std::exception& e) {
12163       {
12164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12165       };
12166     } catch (Dali::DaliException e) {
12167       {
12168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12169       };
12170     } catch (...) {
12171       {
12172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12173       };
12174     }
12175   }
12176
12177   jresult = result;
12178   return jresult;
12179 }
12180
12181
12182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12183   void * jresult ;
12184   Dali::Matrix *result = 0 ;
12185
12186   {
12187     try {
12188       result = (Dali::Matrix *)new Dali::Matrix();
12189     } catch (std::out_of_range& e) {
12190       {
12191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12192       };
12193     } catch (std::exception& e) {
12194       {
12195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12196       };
12197     } catch (Dali::DaliException e) {
12198       {
12199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12200       };
12201     } catch (...) {
12202       {
12203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12204       };
12205     }
12206   }
12207
12208   jresult = (void *)result;
12209   return jresult;
12210 }
12211
12212
12213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12214   void * jresult ;
12215   bool arg1 ;
12216   Dali::Matrix *result = 0 ;
12217
12218   arg1 = jarg1 ? true : false;
12219   {
12220     try {
12221       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12222     } catch (std::out_of_range& e) {
12223       {
12224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12225       };
12226     } catch (std::exception& e) {
12227       {
12228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12229       };
12230     } catch (Dali::DaliException e) {
12231       {
12232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12233       };
12234     } catch (...) {
12235       {
12236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12237       };
12238     }
12239   }
12240
12241   jresult = (void *)result;
12242   return jresult;
12243 }
12244
12245
12246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12247   void * jresult ;
12248   float *arg1 = (float *) 0 ;
12249   Dali::Matrix *result = 0 ;
12250
12251   arg1 = jarg1;
12252   {
12253     try {
12254       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12255     } catch (std::out_of_range& e) {
12256       {
12257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12258       };
12259     } catch (std::exception& e) {
12260       {
12261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12262       };
12263     } catch (Dali::DaliException e) {
12264       {
12265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12266       };
12267     } catch (...) {
12268       {
12269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12270       };
12271     }
12272   }
12273
12274   jresult = (void *)result;
12275
12276
12277   return jresult;
12278 }
12279
12280
12281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12282   void * jresult ;
12283   Dali::Quaternion *arg1 = 0 ;
12284   Dali::Matrix *result = 0 ;
12285
12286   arg1 = (Dali::Quaternion *)jarg1;
12287   if (!arg1) {
12288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12289     return 0;
12290   }
12291   {
12292     try {
12293       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12294     } catch (std::out_of_range& e) {
12295       {
12296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12297       };
12298     } catch (std::exception& e) {
12299       {
12300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12301       };
12302     } catch (Dali::DaliException e) {
12303       {
12304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12305       };
12306     } catch (...) {
12307       {
12308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12309       };
12310     }
12311   }
12312
12313   jresult = (void *)result;
12314   return jresult;
12315 }
12316
12317
12318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12319   void * jresult ;
12320   Dali::Matrix *arg1 = 0 ;
12321   Dali::Matrix *result = 0 ;
12322
12323   arg1 = (Dali::Matrix *)jarg1;
12324   if (!arg1) {
12325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12326     return 0;
12327   }
12328   {
12329     try {
12330       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12331     } catch (std::out_of_range& e) {
12332       {
12333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12334       };
12335     } catch (std::exception& e) {
12336       {
12337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12338       };
12339     } catch (Dali::DaliException e) {
12340       {
12341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12342       };
12343     } catch (...) {
12344       {
12345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12346       };
12347     }
12348   }
12349
12350   jresult = (void *)result;
12351   return jresult;
12352 }
12353
12354
12355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12356   void * jresult ;
12357   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12358   Dali::Matrix *arg2 = 0 ;
12359   Dali::Matrix *result = 0 ;
12360
12361   arg1 = (Dali::Matrix *)jarg1;
12362   arg2 = (Dali::Matrix *)jarg2;
12363   if (!arg2) {
12364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12365     return 0;
12366   }
12367   {
12368     try {
12369       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12370     } catch (std::out_of_range& e) {
12371       {
12372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12373       };
12374     } catch (std::exception& e) {
12375       {
12376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12377       };
12378     } catch (Dali::DaliException e) {
12379       {
12380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12381       };
12382     } catch (...) {
12383       {
12384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12385       };
12386     }
12387   }
12388
12389   jresult = (void *)result;
12390   return jresult;
12391 }
12392
12393
12394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12395   void * jresult ;
12396   Dali::Matrix *result = 0 ;
12397
12398   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12399   jresult = (void *)result;
12400   return jresult;
12401 }
12402
12403
12404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12405   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12406
12407   arg1 = (Dali::Matrix *)jarg1;
12408   {
12409     try {
12410       (arg1)->SetIdentity();
12411     } catch (std::out_of_range& e) {
12412       {
12413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12414       };
12415     } catch (std::exception& e) {
12416       {
12417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12418       };
12419     } catch (Dali::DaliException e) {
12420       {
12421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12422       };
12423     } catch (...) {
12424       {
12425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12426       };
12427     }
12428   }
12429
12430 }
12431
12432
12433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12434   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12435   Dali::Vector3 *arg2 = 0 ;
12436
12437   arg1 = (Dali::Matrix *)jarg1;
12438   arg2 = (Dali::Vector3 *)jarg2;
12439   if (!arg2) {
12440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12441     return ;
12442   }
12443   {
12444     try {
12445       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12446     } catch (std::out_of_range& e) {
12447       {
12448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12449       };
12450     } catch (std::exception& e) {
12451       {
12452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12453       };
12454     } catch (Dali::DaliException e) {
12455       {
12456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12457       };
12458     } catch (...) {
12459       {
12460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12461       };
12462     }
12463   }
12464
12465 }
12466
12467
12468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12469   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12470   Dali::Matrix *arg2 = 0 ;
12471
12472   arg1 = (Dali::Matrix *)jarg1;
12473   arg2 = (Dali::Matrix *)jarg2;
12474   if (!arg2) {
12475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12476     return ;
12477   }
12478   {
12479     try {
12480       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12481     } catch (std::out_of_range& e) {
12482       {
12483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12484       };
12485     } catch (std::exception& e) {
12486       {
12487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12488       };
12489     } catch (Dali::DaliException e) {
12490       {
12491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12492       };
12493     } catch (...) {
12494       {
12495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12496       };
12497     }
12498   }
12499
12500 }
12501
12502
12503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12504   unsigned int jresult ;
12505   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12506   bool result;
12507
12508   arg1 = (Dali::Matrix *)jarg1;
12509   {
12510     try {
12511       result = (bool)(arg1)->Invert();
12512     } catch (std::out_of_range& e) {
12513       {
12514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12515       };
12516     } catch (std::exception& e) {
12517       {
12518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12519       };
12520     } catch (Dali::DaliException e) {
12521       {
12522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12523       };
12524     } catch (...) {
12525       {
12526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12527       };
12528     }
12529   }
12530
12531   jresult = result;
12532   return jresult;
12533 }
12534
12535
12536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12537   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12538
12539   arg1 = (Dali::Matrix *)jarg1;
12540   {
12541     try {
12542       (arg1)->Transpose();
12543     } catch (std::out_of_range& e) {
12544       {
12545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12546       };
12547     } catch (std::exception& e) {
12548       {
12549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12550       };
12551     } catch (Dali::DaliException e) {
12552       {
12553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12554       };
12555     } catch (...) {
12556       {
12557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12558       };
12559     }
12560   }
12561
12562 }
12563
12564
12565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12566   void * jresult ;
12567   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12568   Dali::Vector3 result;
12569
12570   arg1 = (Dali::Matrix *)jarg1;
12571   {
12572     try {
12573       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12574     } catch (std::out_of_range& e) {
12575       {
12576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12577       };
12578     } catch (std::exception& e) {
12579       {
12580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12581       };
12582     } catch (Dali::DaliException e) {
12583       {
12584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12585       };
12586     } catch (...) {
12587       {
12588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12589       };
12590     }
12591   }
12592
12593   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12594   return jresult;
12595 }
12596
12597
12598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12599   void * jresult ;
12600   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12601   Dali::Vector3 result;
12602
12603   arg1 = (Dali::Matrix *)jarg1;
12604   {
12605     try {
12606       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12607     } catch (std::out_of_range& e) {
12608       {
12609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12610       };
12611     } catch (std::exception& e) {
12612       {
12613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12614       };
12615     } catch (Dali::DaliException e) {
12616       {
12617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12618       };
12619     } catch (...) {
12620       {
12621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12622       };
12623     }
12624   }
12625
12626   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12627   return jresult;
12628 }
12629
12630
12631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12632   void * jresult ;
12633   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12634   Dali::Vector3 result;
12635
12636   arg1 = (Dali::Matrix *)jarg1;
12637   {
12638     try {
12639       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12640     } catch (std::out_of_range& e) {
12641       {
12642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12643       };
12644     } catch (std::exception& e) {
12645       {
12646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12647       };
12648     } catch (Dali::DaliException e) {
12649       {
12650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12651       };
12652     } catch (...) {
12653       {
12654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12655       };
12656     }
12657   }
12658
12659   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12660   return jresult;
12661 }
12662
12663
12664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12665   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12666   Dali::Vector3 *arg2 = 0 ;
12667
12668   arg1 = (Dali::Matrix *)jarg1;
12669   arg2 = (Dali::Vector3 *)jarg2;
12670   if (!arg2) {
12671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12672     return ;
12673   }
12674   {
12675     try {
12676       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12677     } catch (std::out_of_range& e) {
12678       {
12679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12680       };
12681     } catch (std::exception& e) {
12682       {
12683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12684       };
12685     } catch (Dali::DaliException e) {
12686       {
12687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12688       };
12689     } catch (...) {
12690       {
12691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12692       };
12693     }
12694   }
12695
12696 }
12697
12698
12699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12700   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12701   Dali::Vector3 *arg2 = 0 ;
12702
12703   arg1 = (Dali::Matrix *)jarg1;
12704   arg2 = (Dali::Vector3 *)jarg2;
12705   if (!arg2) {
12706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12707     return ;
12708   }
12709   {
12710     try {
12711       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12712     } catch (std::out_of_range& e) {
12713       {
12714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12715       };
12716     } catch (std::exception& e) {
12717       {
12718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12719       };
12720     } catch (Dali::DaliException e) {
12721       {
12722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12723       };
12724     } catch (...) {
12725       {
12726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12727       };
12728     }
12729   }
12730
12731 }
12732
12733
12734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12735   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12736   Dali::Vector3 *arg2 = 0 ;
12737
12738   arg1 = (Dali::Matrix *)jarg1;
12739   arg2 = (Dali::Vector3 *)jarg2;
12740   if (!arg2) {
12741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12742     return ;
12743   }
12744   {
12745     try {
12746       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12747     } catch (std::out_of_range& e) {
12748       {
12749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12750       };
12751     } catch (std::exception& e) {
12752       {
12753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12754       };
12755     } catch (Dali::DaliException e) {
12756       {
12757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12758       };
12759     } catch (...) {
12760       {
12761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12762       };
12763     }
12764   }
12765
12766 }
12767
12768
12769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12770   void * jresult ;
12771   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12772   Dali::Vector4 *result = 0 ;
12773
12774   arg1 = (Dali::Matrix *)jarg1;
12775   {
12776     try {
12777       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12778     } catch (std::out_of_range& e) {
12779       {
12780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12781       };
12782     } catch (std::exception& e) {
12783       {
12784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12785       };
12786     } catch (Dali::DaliException e) {
12787       {
12788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12789       };
12790     } catch (...) {
12791       {
12792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12793       };
12794     }
12795   }
12796
12797   jresult = (void *)result;
12798   return jresult;
12799 }
12800
12801
12802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12803   void * jresult ;
12804   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12805   Dali::Vector3 *result = 0 ;
12806
12807   arg1 = (Dali::Matrix *)jarg1;
12808   {
12809     try {
12810       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12811     } catch (std::out_of_range& e) {
12812       {
12813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12814       };
12815     } catch (std::exception& e) {
12816       {
12817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12818       };
12819     } catch (Dali::DaliException e) {
12820       {
12821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12822       };
12823     } catch (...) {
12824       {
12825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12826       };
12827     }
12828   }
12829
12830   jresult = (void *)result;
12831   return jresult;
12832 }
12833
12834
12835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12836   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12837   Dali::Vector4 *arg2 = 0 ;
12838
12839   arg1 = (Dali::Matrix *)jarg1;
12840   arg2 = (Dali::Vector4 *)jarg2;
12841   if (!arg2) {
12842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12843     return ;
12844   }
12845   {
12846     try {
12847       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12848     } catch (std::out_of_range& e) {
12849       {
12850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12851       };
12852     } catch (std::exception& e) {
12853       {
12854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12855       };
12856     } catch (Dali::DaliException e) {
12857       {
12858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12859       };
12860     } catch (...) {
12861       {
12862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12863       };
12864     }
12865   }
12866
12867 }
12868
12869
12870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12871   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12872   Dali::Vector3 *arg2 = 0 ;
12873
12874   arg1 = (Dali::Matrix *)jarg1;
12875   arg2 = (Dali::Vector3 *)jarg2;
12876   if (!arg2) {
12877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12878     return ;
12879   }
12880   {
12881     try {
12882       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12883     } catch (std::out_of_range& e) {
12884       {
12885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12886       };
12887     } catch (std::exception& e) {
12888       {
12889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12890       };
12891     } catch (Dali::DaliException e) {
12892       {
12893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12894       };
12895     } catch (...) {
12896       {
12897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12898       };
12899     }
12900   }
12901
12902 }
12903
12904
12905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12906   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12907
12908   arg1 = (Dali::Matrix *)jarg1;
12909   {
12910     try {
12911       (arg1)->OrthoNormalize();
12912     } catch (std::out_of_range& e) {
12913       {
12914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12915       };
12916     } catch (std::exception& e) {
12917       {
12918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12919       };
12920     } catch (Dali::DaliException e) {
12921       {
12922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12923       };
12924     } catch (...) {
12925       {
12926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12927       };
12928     }
12929   }
12930
12931 }
12932
12933
12934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12935   void * jresult ;
12936   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12937   float *result = 0 ;
12938
12939   arg1 = (Dali::Matrix *)jarg1;
12940   {
12941     try {
12942       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12943     } catch (std::out_of_range& e) {
12944       {
12945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12946       };
12947     } catch (std::exception& e) {
12948       {
12949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12950       };
12951     } catch (Dali::DaliException e) {
12952       {
12953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12954       };
12955     } catch (...) {
12956       {
12957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12958       };
12959     }
12960   }
12961
12962   jresult = (void *)result;
12963   return jresult;
12964 }
12965
12966
12967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12968   Dali::Matrix *arg1 = 0 ;
12969   Dali::Matrix *arg2 = 0 ;
12970   Dali::Matrix *arg3 = 0 ;
12971
12972   arg1 = (Dali::Matrix *)jarg1;
12973   if (!arg1) {
12974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12975     return ;
12976   }
12977   arg2 = (Dali::Matrix *)jarg2;
12978   if (!arg2) {
12979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12980     return ;
12981   }
12982   arg3 = (Dali::Matrix *)jarg3;
12983   if (!arg3) {
12984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12985     return ;
12986   }
12987   {
12988     try {
12989       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12990     } catch (std::out_of_range& e) {
12991       {
12992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12993       };
12994     } catch (std::exception& e) {
12995       {
12996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12997       };
12998     } catch (Dali::DaliException e) {
12999       {
13000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13001       };
13002     } catch (...) {
13003       {
13004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13005       };
13006     }
13007   }
13008
13009 }
13010
13011
13012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
13013   Dali::Matrix *arg1 = 0 ;
13014   Dali::Matrix *arg2 = 0 ;
13015   Dali::Quaternion *arg3 = 0 ;
13016
13017   arg1 = (Dali::Matrix *)jarg1;
13018   if (!arg1) {
13019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
13020     return ;
13021   }
13022   arg2 = (Dali::Matrix *)jarg2;
13023   if (!arg2) {
13024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13025     return ;
13026   }
13027   arg3 = (Dali::Quaternion *)jarg3;
13028   if (!arg3) {
13029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13030     return ;
13031   }
13032   {
13033     try {
13034       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
13035     } catch (std::out_of_range& e) {
13036       {
13037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13038       };
13039     } catch (std::exception& e) {
13040       {
13041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13042       };
13043     } catch (Dali::DaliException e) {
13044       {
13045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13046       };
13047     } catch (...) {
13048       {
13049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13050       };
13051     }
13052   }
13053
13054 }
13055
13056
13057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13058   void * jresult ;
13059   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13060   Dali::Vector4 *arg2 = 0 ;
13061   Dali::Vector4 result;
13062
13063   arg1 = (Dali::Matrix *)jarg1;
13064   arg2 = (Dali::Vector4 *)jarg2;
13065   if (!arg2) {
13066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13067     return 0;
13068   }
13069   {
13070     try {
13071       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13072     } catch (std::out_of_range& e) {
13073       {
13074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13075       };
13076     } catch (std::exception& e) {
13077       {
13078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13079       };
13080     } catch (Dali::DaliException e) {
13081       {
13082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13083       };
13084     } catch (...) {
13085       {
13086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13087       };
13088     }
13089   }
13090
13091   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13092   return jresult;
13093 }
13094
13095
13096 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13097   unsigned int jresult ;
13098   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13099   Dali::Matrix *arg2 = 0 ;
13100   bool result;
13101
13102   arg1 = (Dali::Matrix *)jarg1;
13103   arg2 = (Dali::Matrix *)jarg2;
13104   if (!arg2) {
13105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13106     return 0;
13107   }
13108   {
13109     try {
13110       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13111     } catch (std::out_of_range& e) {
13112       {
13113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13114       };
13115     } catch (std::exception& e) {
13116       {
13117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13118       };
13119     } catch (Dali::DaliException e) {
13120       {
13121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13122       };
13123     } catch (...) {
13124       {
13125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13126       };
13127     }
13128   }
13129
13130   jresult = result;
13131   return jresult;
13132 }
13133
13134
13135 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13136   unsigned int jresult ;
13137   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13138   Dali::Matrix *arg2 = 0 ;
13139   bool result;
13140
13141   arg1 = (Dali::Matrix *)jarg1;
13142   arg2 = (Dali::Matrix *)jarg2;
13143   if (!arg2) {
13144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13145     return 0;
13146   }
13147   {
13148     try {
13149       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13150     } catch (std::out_of_range& e) {
13151       {
13152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13153       };
13154     } catch (std::exception& e) {
13155       {
13156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13157       };
13158     } catch (Dali::DaliException e) {
13159       {
13160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13161       };
13162     } catch (...) {
13163       {
13164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13165       };
13166     }
13167   }
13168
13169   jresult = result;
13170   return jresult;
13171 }
13172
13173
13174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13175   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13176   Dali::Vector3 *arg2 = 0 ;
13177   Dali::Quaternion *arg3 = 0 ;
13178   Dali::Vector3 *arg4 = 0 ;
13179
13180   arg1 = (Dali::Matrix *)jarg1;
13181   arg2 = (Dali::Vector3 *)jarg2;
13182   if (!arg2) {
13183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13184     return ;
13185   }
13186   arg3 = (Dali::Quaternion *)jarg3;
13187   if (!arg3) {
13188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13189     return ;
13190   }
13191   arg4 = (Dali::Vector3 *)jarg4;
13192   if (!arg4) {
13193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13194     return ;
13195   }
13196   {
13197     try {
13198       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13199     } catch (std::out_of_range& e) {
13200       {
13201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13202       };
13203     } catch (std::exception& e) {
13204       {
13205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13206       };
13207     } catch (Dali::DaliException e) {
13208       {
13209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13210       };
13211     } catch (...) {
13212       {
13213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13214       };
13215     }
13216   }
13217
13218 }
13219
13220
13221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13222   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13223   Dali::Vector3 *arg2 = 0 ;
13224   Dali::Quaternion *arg3 = 0 ;
13225   Dali::Vector3 *arg4 = 0 ;
13226
13227   arg1 = (Dali::Matrix *)jarg1;
13228   arg2 = (Dali::Vector3 *)jarg2;
13229   if (!arg2) {
13230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13231     return ;
13232   }
13233   arg3 = (Dali::Quaternion *)jarg3;
13234   if (!arg3) {
13235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13236     return ;
13237   }
13238   arg4 = (Dali::Vector3 *)jarg4;
13239   if (!arg4) {
13240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13241     return ;
13242   }
13243   {
13244     try {
13245       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13246     } catch (std::out_of_range& e) {
13247       {
13248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13249       };
13250     } catch (std::exception& e) {
13251       {
13252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13253       };
13254     } catch (Dali::DaliException e) {
13255       {
13256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13257       };
13258     } catch (...) {
13259       {
13260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13261       };
13262     }
13263   }
13264
13265 }
13266
13267
13268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13269   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13270   Dali::Vector3 *arg2 = 0 ;
13271   Dali::Vector3 *arg3 = 0 ;
13272   Dali::Vector3 *arg4 = 0 ;
13273   Dali::Vector3 *arg5 = 0 ;
13274
13275   arg1 = (Dali::Matrix *)jarg1;
13276   arg2 = (Dali::Vector3 *)jarg2;
13277   if (!arg2) {
13278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13279     return ;
13280   }
13281   arg3 = (Dali::Vector3 *)jarg3;
13282   if (!arg3) {
13283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13284     return ;
13285   }
13286   arg4 = (Dali::Vector3 *)jarg4;
13287   if (!arg4) {
13288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13289     return ;
13290   }
13291   arg5 = (Dali::Vector3 *)jarg5;
13292   if (!arg5) {
13293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13294     return ;
13295   }
13296   {
13297     try {
13298       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13299     } catch (std::out_of_range& e) {
13300       {
13301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13302       };
13303     } catch (std::exception& e) {
13304       {
13305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13306       };
13307     } catch (Dali::DaliException e) {
13308       {
13309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13310       };
13311     } catch (...) {
13312       {
13313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13314       };
13315     }
13316   }
13317
13318 }
13319
13320
13321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13322   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13323   Dali::Vector3 *arg2 = 0 ;
13324   Dali::Quaternion *arg3 = 0 ;
13325   Dali::Vector3 *arg4 = 0 ;
13326
13327   arg1 = (Dali::Matrix *)jarg1;
13328   arg2 = (Dali::Vector3 *)jarg2;
13329   if (!arg2) {
13330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13331     return ;
13332   }
13333   arg3 = (Dali::Quaternion *)jarg3;
13334   if (!arg3) {
13335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13336     return ;
13337   }
13338   arg4 = (Dali::Vector3 *)jarg4;
13339   if (!arg4) {
13340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13341     return ;
13342   }
13343   {
13344     try {
13345       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13346     } catch (std::out_of_range& e) {
13347       {
13348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13349       };
13350     } catch (std::exception& e) {
13351       {
13352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13353       };
13354     } catch (Dali::DaliException e) {
13355       {
13356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13357       };
13358     } catch (...) {
13359       {
13360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13361       };
13362     }
13363   }
13364
13365 }
13366
13367
13368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13369   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13370
13371   arg1 = (Dali::Matrix *)jarg1;
13372   {
13373     try {
13374       delete arg1;
13375     } catch (std::out_of_range& e) {
13376       {
13377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13378       };
13379     } catch (std::exception& e) {
13380       {
13381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13382       };
13383     } catch (Dali::DaliException e) {
13384       {
13385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13386       };
13387     } catch (...) {
13388       {
13389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13390       };
13391     }
13392   }
13393
13394 }
13395
13396
13397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13398   void * jresult ;
13399   Dali::Matrix3 *result = 0 ;
13400
13401   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13402   jresult = (void *)result;
13403   return jresult;
13404 }
13405
13406
13407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13408   void * jresult ;
13409   Dali::Matrix3 *result = 0 ;
13410
13411   {
13412     try {
13413       result = (Dali::Matrix3 *)new Dali::Matrix3();
13414     } catch (std::out_of_range& e) {
13415       {
13416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13417       };
13418     } catch (std::exception& e) {
13419       {
13420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13421       };
13422     } catch (Dali::DaliException e) {
13423       {
13424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13425       };
13426     } catch (...) {
13427       {
13428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13429       };
13430     }
13431   }
13432
13433   jresult = (void *)result;
13434   return jresult;
13435 }
13436
13437
13438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13439   void * jresult ;
13440   Dali::Matrix3 *arg1 = 0 ;
13441   Dali::Matrix3 *result = 0 ;
13442
13443   arg1 = (Dali::Matrix3 *)jarg1;
13444   if (!arg1) {
13445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13446     return 0;
13447   }
13448   {
13449     try {
13450       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13451     } catch (std::out_of_range& e) {
13452       {
13453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13454       };
13455     } catch (std::exception& e) {
13456       {
13457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13458       };
13459     } catch (Dali::DaliException e) {
13460       {
13461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13462       };
13463     } catch (...) {
13464       {
13465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13466       };
13467     }
13468   }
13469
13470   jresult = (void *)result;
13471   return jresult;
13472 }
13473
13474
13475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13476   void * jresult ;
13477   Dali::Matrix *arg1 = 0 ;
13478   Dali::Matrix3 *result = 0 ;
13479
13480   arg1 = (Dali::Matrix *)jarg1;
13481   if (!arg1) {
13482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13483     return 0;
13484   }
13485   {
13486     try {
13487       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13488     } catch (std::out_of_range& e) {
13489       {
13490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13491       };
13492     } catch (std::exception& e) {
13493       {
13494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13495       };
13496     } catch (Dali::DaliException e) {
13497       {
13498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13499       };
13500     } catch (...) {
13501       {
13502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13503       };
13504     }
13505   }
13506
13507   jresult = (void *)result;
13508   return jresult;
13509 }
13510
13511
13512 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) {
13513   void * jresult ;
13514   float arg1 ;
13515   float arg2 ;
13516   float arg3 ;
13517   float arg4 ;
13518   float arg5 ;
13519   float arg6 ;
13520   float arg7 ;
13521   float arg8 ;
13522   float arg9 ;
13523   Dali::Matrix3 *result = 0 ;
13524
13525   arg1 = (float)jarg1;
13526   arg2 = (float)jarg2;
13527   arg3 = (float)jarg3;
13528   arg4 = (float)jarg4;
13529   arg5 = (float)jarg5;
13530   arg6 = (float)jarg6;
13531   arg7 = (float)jarg7;
13532   arg8 = (float)jarg8;
13533   arg9 = (float)jarg9;
13534   {
13535     try {
13536       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13537     } catch (std::out_of_range& e) {
13538       {
13539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13540       };
13541     } catch (std::exception& e) {
13542       {
13543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13544       };
13545     } catch (Dali::DaliException e) {
13546       {
13547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13548       };
13549     } catch (...) {
13550       {
13551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13552       };
13553     }
13554   }
13555
13556   jresult = (void *)result;
13557   return jresult;
13558 }
13559
13560
13561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13562   void * jresult ;
13563   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13564   Dali::Matrix3 *arg2 = 0 ;
13565   Dali::Matrix3 *result = 0 ;
13566
13567   arg1 = (Dali::Matrix3 *)jarg1;
13568   arg2 = (Dali::Matrix3 *)jarg2;
13569   if (!arg2) {
13570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13571     return 0;
13572   }
13573   {
13574     try {
13575       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13576     } catch (std::out_of_range& e) {
13577       {
13578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13579       };
13580     } catch (std::exception& e) {
13581       {
13582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13583       };
13584     } catch (Dali::DaliException e) {
13585       {
13586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13587       };
13588     } catch (...) {
13589       {
13590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13591       };
13592     }
13593   }
13594
13595   jresult = (void *)result;
13596   return jresult;
13597 }
13598
13599
13600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13601   void * jresult ;
13602   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13603   Dali::Matrix *arg2 = 0 ;
13604   Dali::Matrix3 *result = 0 ;
13605
13606   arg1 = (Dali::Matrix3 *)jarg1;
13607   arg2 = (Dali::Matrix *)jarg2;
13608   if (!arg2) {
13609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13610     return 0;
13611   }
13612   {
13613     try {
13614       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13615     } catch (std::out_of_range& e) {
13616       {
13617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13618       };
13619     } catch (std::exception& e) {
13620       {
13621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13622       };
13623     } catch (Dali::DaliException e) {
13624       {
13625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13626       };
13627     } catch (...) {
13628       {
13629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13630       };
13631     }
13632   }
13633
13634   jresult = (void *)result;
13635   return jresult;
13636 }
13637
13638
13639 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13640   unsigned int jresult ;
13641   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13642   Dali::Matrix3 *arg2 = 0 ;
13643   bool result;
13644
13645   arg1 = (Dali::Matrix3 *)jarg1;
13646   arg2 = (Dali::Matrix3 *)jarg2;
13647   if (!arg2) {
13648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13649     return 0;
13650   }
13651   {
13652     try {
13653       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13654     } catch (std::out_of_range& e) {
13655       {
13656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13657       };
13658     } catch (std::exception& e) {
13659       {
13660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13661       };
13662     } catch (Dali::DaliException e) {
13663       {
13664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13665       };
13666     } catch (...) {
13667       {
13668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13669       };
13670     }
13671   }
13672
13673   jresult = result;
13674   return jresult;
13675 }
13676
13677
13678 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13679   unsigned int jresult ;
13680   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13681   Dali::Matrix3 *arg2 = 0 ;
13682   bool result;
13683
13684   arg1 = (Dali::Matrix3 *)jarg1;
13685   arg2 = (Dali::Matrix3 *)jarg2;
13686   if (!arg2) {
13687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13688     return 0;
13689   }
13690   {
13691     try {
13692       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13693     } catch (std::out_of_range& e) {
13694       {
13695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13696       };
13697     } catch (std::exception& e) {
13698       {
13699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13700       };
13701     } catch (Dali::DaliException e) {
13702       {
13703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13704       };
13705     } catch (...) {
13706       {
13707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13708       };
13709     }
13710   }
13711
13712   jresult = result;
13713   return jresult;
13714 }
13715
13716
13717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13718   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13719
13720   arg1 = (Dali::Matrix3 *)jarg1;
13721   {
13722     try {
13723       delete arg1;
13724     } catch (std::out_of_range& e) {
13725       {
13726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13727       };
13728     } catch (std::exception& e) {
13729       {
13730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13731       };
13732     } catch (Dali::DaliException e) {
13733       {
13734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13735       };
13736     } catch (...) {
13737       {
13738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13739       };
13740     }
13741   }
13742
13743 }
13744
13745
13746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13747   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13748
13749   arg1 = (Dali::Matrix3 *)jarg1;
13750   {
13751     try {
13752       (arg1)->SetIdentity();
13753     } catch (std::out_of_range& e) {
13754       {
13755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13756       };
13757     } catch (std::exception& e) {
13758       {
13759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13760       };
13761     } catch (Dali::DaliException e) {
13762       {
13763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13764       };
13765     } catch (...) {
13766       {
13767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13768       };
13769     }
13770   }
13771
13772 }
13773
13774
13775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13776   void * jresult ;
13777   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13778   float *result = 0 ;
13779
13780   arg1 = (Dali::Matrix3 *)jarg1;
13781   {
13782     try {
13783       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13784     } catch (std::out_of_range& e) {
13785       {
13786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13787       };
13788     } catch (std::exception& e) {
13789       {
13790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13791       };
13792     } catch (Dali::DaliException e) {
13793       {
13794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13795       };
13796     } catch (...) {
13797       {
13798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13799       };
13800     }
13801   }
13802
13803   jresult = (void *)result;
13804   return jresult;
13805 }
13806
13807
13808 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13809   unsigned int jresult ;
13810   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13811   bool result;
13812
13813   arg1 = (Dali::Matrix3 *)jarg1;
13814   {
13815     try {
13816       result = (bool)(arg1)->Invert();
13817     } catch (std::out_of_range& e) {
13818       {
13819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13820       };
13821     } catch (std::exception& e) {
13822       {
13823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13824       };
13825     } catch (Dali::DaliException e) {
13826       {
13827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13828       };
13829     } catch (...) {
13830       {
13831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13832       };
13833     }
13834   }
13835
13836   jresult = result;
13837   return jresult;
13838 }
13839
13840
13841 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13842   unsigned int jresult ;
13843   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13844   bool result;
13845
13846   arg1 = (Dali::Matrix3 *)jarg1;
13847   {
13848     try {
13849       result = (bool)(arg1)->Transpose();
13850     } catch (std::out_of_range& e) {
13851       {
13852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13853       };
13854     } catch (std::exception& e) {
13855       {
13856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13857       };
13858     } catch (Dali::DaliException e) {
13859       {
13860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13861       };
13862     } catch (...) {
13863       {
13864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13865       };
13866     }
13867   }
13868
13869   jresult = result;
13870   return jresult;
13871 }
13872
13873
13874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13875   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13876   float arg2 ;
13877
13878   arg1 = (Dali::Matrix3 *)jarg1;
13879   arg2 = (float)jarg2;
13880   {
13881     try {
13882       (arg1)->Scale(arg2);
13883     } catch (std::out_of_range& e) {
13884       {
13885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13886       };
13887     } catch (std::exception& e) {
13888       {
13889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13890       };
13891     } catch (Dali::DaliException e) {
13892       {
13893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13894       };
13895     } catch (...) {
13896       {
13897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13898       };
13899     }
13900   }
13901
13902 }
13903
13904
13905 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13906   float jresult ;
13907   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13908   float result;
13909
13910   arg1 = (Dali::Matrix3 *)jarg1;
13911   {
13912     try {
13913       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13914     } catch (std::out_of_range& e) {
13915       {
13916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13917       };
13918     } catch (std::exception& e) {
13919       {
13920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13921       };
13922     } catch (Dali::DaliException e) {
13923       {
13924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13925       };
13926     } catch (...) {
13927       {
13928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13929       };
13930     }
13931   }
13932
13933   jresult = result;
13934   return jresult;
13935 }
13936
13937
13938 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13939   unsigned int jresult ;
13940   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13941   bool result;
13942
13943   arg1 = (Dali::Matrix3 *)jarg1;
13944   {
13945     try {
13946       result = (bool)(arg1)->ScaledInverseTranspose();
13947     } catch (std::out_of_range& e) {
13948       {
13949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13950       };
13951     } catch (std::exception& e) {
13952       {
13953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13954       };
13955     } catch (Dali::DaliException e) {
13956       {
13957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13958       };
13959     } catch (...) {
13960       {
13961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13962       };
13963     }
13964   }
13965
13966   jresult = result;
13967   return jresult;
13968 }
13969
13970
13971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13972   Dali::Matrix3 *arg1 = 0 ;
13973   Dali::Matrix3 *arg2 = 0 ;
13974   Dali::Matrix3 *arg3 = 0 ;
13975
13976   arg1 = (Dali::Matrix3 *)jarg1;
13977   if (!arg1) {
13978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13979     return ;
13980   }
13981   arg2 = (Dali::Matrix3 *)jarg2;
13982   if (!arg2) {
13983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13984     return ;
13985   }
13986   arg3 = (Dali::Matrix3 *)jarg3;
13987   if (!arg3) {
13988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13989     return ;
13990   }
13991   {
13992     try {
13993       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13994     } catch (std::out_of_range& e) {
13995       {
13996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13997       };
13998     } catch (std::exception& e) {
13999       {
14000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14001       };
14002     } catch (Dali::DaliException e) {
14003       {
14004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14005       };
14006     } catch (...) {
14007       {
14008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14009       };
14010     }
14011   }
14012
14013 }
14014
14015
14016 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
14017   float jresult ;
14018   float arg1 ;
14019   float arg2 ;
14020   float result;
14021
14022   arg1 = (float)jarg1;
14023   arg2 = (float)jarg2;
14024   {
14025     try {
14026       result = (float)Dali::Random::Range(arg1,arg2);
14027     } catch (std::out_of_range& e) {
14028       {
14029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14030       };
14031     } catch (std::exception& e) {
14032       {
14033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14034       };
14035     } catch (Dali::DaliException e) {
14036       {
14037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14038       };
14039     } catch (...) {
14040       {
14041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14042       };
14043     }
14044   }
14045
14046   jresult = result;
14047   return jresult;
14048 }
14049
14050
14051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14052   void * jresult ;
14053   Dali::Vector4 result;
14054
14055   {
14056     try {
14057       result = Dali::Random::Axis();
14058     } catch (std::out_of_range& e) {
14059       {
14060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14061       };
14062     } catch (std::exception& e) {
14063       {
14064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14065       };
14066     } catch (Dali::DaliException e) {
14067       {
14068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14069       };
14070     } catch (...) {
14071       {
14072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14073       };
14074     }
14075   }
14076
14077   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14078   return jresult;
14079 }
14080
14081
14082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14083   void * jresult ;
14084   Dali::AngleAxis *result = 0 ;
14085
14086   {
14087     try {
14088       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14089     } catch (std::out_of_range& e) {
14090       {
14091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14092       };
14093     } catch (std::exception& e) {
14094       {
14095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14096       };
14097     } catch (Dali::DaliException e) {
14098       {
14099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14100       };
14101     } catch (...) {
14102       {
14103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14104       };
14105     }
14106   }
14107
14108   jresult = (void *)result;
14109   return jresult;
14110 }
14111
14112
14113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14114   void * jresult ;
14115   Dali::Radian arg1 ;
14116   Dali::Vector3 *arg2 = 0 ;
14117   Dali::Radian *argp1 ;
14118   Dali::AngleAxis *result = 0 ;
14119
14120   argp1 = (Dali::Radian *)jarg1;
14121   if (!argp1) {
14122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14123     return 0;
14124   }
14125   arg1 = *argp1;
14126   arg2 = (Dali::Vector3 *)jarg2;
14127   if (!arg2) {
14128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14129     return 0;
14130   }
14131   {
14132     try {
14133       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14134     } catch (std::out_of_range& e) {
14135       {
14136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14137       };
14138     } catch (std::exception& e) {
14139       {
14140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14141       };
14142     } catch (Dali::DaliException e) {
14143       {
14144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14145       };
14146     } catch (...) {
14147       {
14148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14149       };
14150     }
14151   }
14152
14153   jresult = (void *)result;
14154   return jresult;
14155 }
14156
14157
14158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14159   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14160   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14161
14162   arg1 = (Dali::AngleAxis *)jarg1;
14163   arg2 = (Dali::Radian *)jarg2;
14164   if (arg1) (arg1)->angle = *arg2;
14165 }
14166
14167
14168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14169   void * jresult ;
14170   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14171   Dali::Radian *result = 0 ;
14172
14173   arg1 = (Dali::AngleAxis *)jarg1;
14174   result = (Dali::Radian *)& ((arg1)->angle);
14175   jresult = (void *)result;
14176   return jresult;
14177 }
14178
14179
14180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14181   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14182   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14183
14184   arg1 = (Dali::AngleAxis *)jarg1;
14185   arg2 = (Dali::Vector3 *)jarg2;
14186   if (arg1) (arg1)->axis = *arg2;
14187 }
14188
14189
14190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14191   void * jresult ;
14192   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14193   Dali::Vector3 *result = 0 ;
14194
14195   arg1 = (Dali::AngleAxis *)jarg1;
14196   result = (Dali::Vector3 *)& ((arg1)->axis);
14197   jresult = (void *)result;
14198   return jresult;
14199 }
14200
14201
14202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14203   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14204
14205   arg1 = (Dali::AngleAxis *)jarg1;
14206   {
14207     try {
14208       delete arg1;
14209     } catch (std::out_of_range& e) {
14210       {
14211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14212       };
14213     } catch (std::exception& e) {
14214       {
14215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14216       };
14217     } catch (Dali::DaliException e) {
14218       {
14219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14220       };
14221     } catch (...) {
14222       {
14223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14224       };
14225     }
14226   }
14227
14228 }
14229
14230
14231 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14232   unsigned int jresult ;
14233   Dali::AngleAxis *arg1 = 0 ;
14234   Dali::AngleAxis *arg2 = 0 ;
14235   bool result;
14236
14237   arg1 = (Dali::AngleAxis *)jarg1;
14238   if (!arg1) {
14239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14240     return 0;
14241   }
14242   arg2 = (Dali::AngleAxis *)jarg2;
14243   if (!arg2) {
14244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14245     return 0;
14246   }
14247   {
14248     try {
14249       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14250     } catch (std::out_of_range& e) {
14251       {
14252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14253       };
14254     } catch (std::exception& e) {
14255       {
14256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14257       };
14258     } catch (Dali::DaliException e) {
14259       {
14260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14261       };
14262     } catch (...) {
14263       {
14264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14265       };
14266     }
14267   }
14268
14269   jresult = result;
14270   return jresult;
14271 }
14272
14273
14274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14275   unsigned int jresult ;
14276   unsigned int arg1 ;
14277   unsigned int result;
14278
14279   arg1 = (unsigned int)jarg1;
14280   {
14281     try {
14282       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14283     } catch (std::out_of_range& e) {
14284       {
14285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14286       };
14287     } catch (std::exception& e) {
14288       {
14289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14290       };
14291     } catch (Dali::DaliException e) {
14292       {
14293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14294       };
14295     } catch (...) {
14296       {
14297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14298       };
14299     }
14300   }
14301
14302   jresult = result;
14303   return jresult;
14304 }
14305
14306
14307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14308   unsigned int jresult ;
14309   unsigned int arg1 ;
14310   bool result;
14311
14312   arg1 = (unsigned int)jarg1;
14313   {
14314     try {
14315       result = (bool)Dali::IsPowerOfTwo(arg1);
14316     } catch (std::out_of_range& e) {
14317       {
14318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14319       };
14320     } catch (std::exception& e) {
14321       {
14322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14323       };
14324     } catch (Dali::DaliException e) {
14325       {
14326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14327       };
14328     } catch (...) {
14329       {
14330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14331       };
14332     }
14333   }
14334
14335   jresult = result;
14336   return jresult;
14337 }
14338
14339
14340 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14341   float jresult ;
14342   float arg1 ;
14343   float arg2 ;
14344   float result;
14345
14346   arg1 = (float)jarg1;
14347   arg2 = (float)jarg2;
14348   {
14349     try {
14350       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14351     } catch (std::out_of_range& e) {
14352       {
14353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14354       };
14355     } catch (std::exception& e) {
14356       {
14357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14358       };
14359     } catch (Dali::DaliException e) {
14360       {
14361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14362       };
14363     } catch (...) {
14364       {
14365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14366       };
14367     }
14368   }
14369
14370   jresult = result;
14371   return jresult;
14372 }
14373
14374
14375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14376   unsigned int jresult ;
14377   float arg1 ;
14378   bool result;
14379
14380   arg1 = (float)jarg1;
14381   {
14382     try {
14383       result = (bool)Dali::EqualsZero(arg1);
14384     } catch (std::out_of_range& e) {
14385       {
14386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14387       };
14388     } catch (std::exception& e) {
14389       {
14390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14391       };
14392     } catch (Dali::DaliException e) {
14393       {
14394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14395       };
14396     } catch (...) {
14397       {
14398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14399       };
14400     }
14401   }
14402
14403   jresult = result;
14404   return jresult;
14405 }
14406
14407
14408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14409   unsigned int jresult ;
14410   float arg1 ;
14411   float arg2 ;
14412   bool result;
14413
14414   arg1 = (float)jarg1;
14415   arg2 = (float)jarg2;
14416   {
14417     try {
14418       result = (bool)Dali::Equals(arg1,arg2);
14419     } catch (std::out_of_range& e) {
14420       {
14421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14422       };
14423     } catch (std::exception& e) {
14424       {
14425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14426       };
14427     } catch (Dali::DaliException e) {
14428       {
14429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14430       };
14431     } catch (...) {
14432       {
14433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14434       };
14435     }
14436   }
14437
14438   jresult = result;
14439   return jresult;
14440 }
14441
14442
14443 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14444   unsigned int jresult ;
14445   float arg1 ;
14446   float arg2 ;
14447   float arg3 ;
14448   bool result;
14449
14450   arg1 = (float)jarg1;
14451   arg2 = (float)jarg2;
14452   arg3 = (float)jarg3;
14453   {
14454     try {
14455       result = (bool)Dali::Equals(arg1,arg2,arg3);
14456     } catch (std::out_of_range& e) {
14457       {
14458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14459       };
14460     } catch (std::exception& e) {
14461       {
14462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14463       };
14464     } catch (Dali::DaliException e) {
14465       {
14466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14467       };
14468     } catch (...) {
14469       {
14470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14471       };
14472     }
14473   }
14474
14475   jresult = result;
14476   return jresult;
14477 }
14478
14479
14480 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14481   float jresult ;
14482   float arg1 ;
14483   int arg2 ;
14484   float result;
14485
14486   arg1 = (float)jarg1;
14487   arg2 = (int)jarg2;
14488   {
14489     try {
14490       result = (float)Dali::Round(arg1,arg2);
14491     } catch (std::out_of_range& e) {
14492       {
14493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14494       };
14495     } catch (std::exception& e) {
14496       {
14497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14498       };
14499     } catch (Dali::DaliException e) {
14500       {
14501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14502       };
14503     } catch (...) {
14504       {
14505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14506       };
14507     }
14508   }
14509
14510   jresult = result;
14511   return jresult;
14512 }
14513
14514
14515 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14516   float jresult ;
14517   float arg1 ;
14518   float arg2 ;
14519   float arg3 ;
14520   float result;
14521
14522   arg1 = (float)jarg1;
14523   arg2 = (float)jarg2;
14524   arg3 = (float)jarg3;
14525   {
14526     try {
14527       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14528     } catch (std::out_of_range& e) {
14529       {
14530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14531       };
14532     } catch (std::exception& e) {
14533       {
14534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14535       };
14536     } catch (Dali::DaliException e) {
14537       {
14538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14539       };
14540     } catch (...) {
14541       {
14542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14543       };
14544     }
14545   }
14546
14547   jresult = result;
14548   return jresult;
14549 }
14550
14551
14552 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14553   float jresult ;
14554   float arg1 ;
14555   float arg2 ;
14556   float arg3 ;
14557   float arg4 ;
14558   float result;
14559
14560   arg1 = (float)jarg1;
14561   arg2 = (float)jarg2;
14562   arg3 = (float)jarg3;
14563   arg4 = (float)jarg4;
14564   {
14565     try {
14566       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14567     } catch (std::out_of_range& e) {
14568       {
14569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14570       };
14571     } catch (std::exception& e) {
14572       {
14573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14574       };
14575     } catch (Dali::DaliException e) {
14576       {
14577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14578       };
14579     } catch (...) {
14580       {
14581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14582       };
14583     }
14584   }
14585
14586   jresult = result;
14587   return jresult;
14588 }
14589
14590
14591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14592   int jresult ;
14593   int result;
14594
14595   result = (int)(int)Dali::Property::INVALID_INDEX;
14596   jresult = result;
14597   return jresult;
14598 }
14599
14600
14601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14602   int jresult ;
14603   int result;
14604
14605   result = (int)(int)Dali::Property::INVALID_KEY;
14606   jresult = result;
14607   return jresult;
14608 }
14609
14610
14611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14612   int jresult ;
14613   int result;
14614
14615   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14616   jresult = result;
14617   return jresult;
14618 }
14619
14620
14621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14622   void * jresult ;
14623   Dali::Handle *arg1 = 0 ;
14624   Dali::Property::Index arg2 ;
14625   Dali::Property *result = 0 ;
14626
14627   arg1 = (Dali::Handle *)jarg1;
14628   if (!arg1) {
14629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14630     return 0;
14631   }
14632   arg2 = (Dali::Property::Index)jarg2;
14633   {
14634     try {
14635       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14636     } catch (std::out_of_range& e) {
14637       {
14638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14639       };
14640     } catch (std::exception& e) {
14641       {
14642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14643       };
14644     } catch (Dali::DaliException e) {
14645       {
14646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14647       };
14648     } catch (...) {
14649       {
14650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14651       };
14652     }
14653   }
14654
14655   jresult = (void *)result;
14656   return jresult;
14657 }
14658
14659
14660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14661   void * jresult ;
14662   Dali::Handle *arg1 = 0 ;
14663   Dali::Property::Index arg2 ;
14664   int arg3 ;
14665   Dali::Property *result = 0 ;
14666
14667   arg1 = (Dali::Handle *)jarg1;
14668   if (!arg1) {
14669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14670     return 0;
14671   }
14672   arg2 = (Dali::Property::Index)jarg2;
14673   arg3 = (int)jarg3;
14674   {
14675     try {
14676       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14677     } catch (std::out_of_range& e) {
14678       {
14679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14680       };
14681     } catch (std::exception& e) {
14682       {
14683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14684       };
14685     } catch (Dali::DaliException e) {
14686       {
14687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14688       };
14689     } catch (...) {
14690       {
14691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14692       };
14693     }
14694   }
14695
14696   jresult = (void *)result;
14697   return jresult;
14698 }
14699
14700
14701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14702   void * jresult ;
14703   Dali::Handle *arg1 = 0 ;
14704   std::string *arg2 = 0 ;
14705   Dali::Property *result = 0 ;
14706
14707   arg1 = (Dali::Handle *)jarg1;
14708   if (!arg1) {
14709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14710     return 0;
14711   }
14712   if (!jarg2) {
14713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14714     return 0;
14715   }
14716   std::string arg2_str(jarg2);
14717   arg2 = &arg2_str;
14718   {
14719     try {
14720       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14721     } catch (std::out_of_range& e) {
14722       {
14723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14724       };
14725     } catch (std::exception& e) {
14726       {
14727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14728       };
14729     } catch (Dali::DaliException e) {
14730       {
14731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14732       };
14733     } catch (...) {
14734       {
14735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14736       };
14737     }
14738   }
14739
14740   jresult = (void *)result;
14741
14742   //argout typemap for const std::string&
14743
14744   return jresult;
14745 }
14746
14747
14748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14749   void * jresult ;
14750   Dali::Handle *arg1 = 0 ;
14751   std::string *arg2 = 0 ;
14752   int arg3 ;
14753   Dali::Property *result = 0 ;
14754
14755   arg1 = (Dali::Handle *)jarg1;
14756   if (!arg1) {
14757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14758     return 0;
14759   }
14760   if (!jarg2) {
14761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14762     return 0;
14763   }
14764   std::string arg2_str(jarg2);
14765   arg2 = &arg2_str;
14766   arg3 = (int)jarg3;
14767   {
14768     try {
14769       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14770     } catch (std::out_of_range& e) {
14771       {
14772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14773       };
14774     } catch (std::exception& e) {
14775       {
14776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14777       };
14778     } catch (Dali::DaliException e) {
14779       {
14780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14781       };
14782     } catch (...) {
14783       {
14784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14785       };
14786     }
14787   }
14788
14789   jresult = (void *)result;
14790
14791   //argout typemap for const std::string&
14792
14793   return jresult;
14794 }
14795
14796
14797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14798   Dali::Property *arg1 = (Dali::Property *) 0 ;
14799
14800   arg1 = (Dali::Property *)jarg1;
14801   {
14802     try {
14803       delete arg1;
14804     } catch (std::out_of_range& e) {
14805       {
14806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14807       };
14808     } catch (std::exception& e) {
14809       {
14810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14811       };
14812     } catch (Dali::DaliException e) {
14813       {
14814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14815       };
14816     } catch (...) {
14817       {
14818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14819       };
14820     }
14821   }
14822
14823 }
14824
14825
14826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14827   Dali::Property *arg1 = (Dali::Property *) 0 ;
14828   Dali::Handle *arg2 = 0 ;
14829
14830   arg1 = (Dali::Property *)jarg1;
14831   arg2 = (Dali::Handle *)jarg2;
14832   if (!arg2) {
14833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14834     return ;
14835   }
14836   if (arg1) (arg1)->object = *arg2;
14837 }
14838
14839
14840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14841   void * jresult ;
14842   Dali::Property *arg1 = (Dali::Property *) 0 ;
14843   Dali::Handle *result = 0 ;
14844
14845   arg1 = (Dali::Property *)jarg1;
14846   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14847   jresult = (void *)result;
14848   return jresult;
14849 }
14850
14851
14852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14853   Dali::Property *arg1 = (Dali::Property *) 0 ;
14854   Dali::Property::Index arg2 ;
14855
14856   arg1 = (Dali::Property *)jarg1;
14857   arg2 = (Dali::Property::Index)jarg2;
14858   if (arg1) (arg1)->propertyIndex = arg2;
14859 }
14860
14861
14862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14863   int jresult ;
14864   Dali::Property *arg1 = (Dali::Property *) 0 ;
14865   Dali::Property::Index result;
14866
14867   arg1 = (Dali::Property *)jarg1;
14868   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14869   jresult = result;
14870   return jresult;
14871 }
14872
14873
14874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14875   Dali::Property *arg1 = (Dali::Property *) 0 ;
14876   int arg2 ;
14877
14878   arg1 = (Dali::Property *)jarg1;
14879   arg2 = (int)jarg2;
14880   if (arg1) (arg1)->componentIndex = arg2;
14881 }
14882
14883
14884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14885   int jresult ;
14886   Dali::Property *arg1 = (Dali::Property *) 0 ;
14887   int result;
14888
14889   arg1 = (Dali::Property *)jarg1;
14890   result = (int) ((arg1)->componentIndex);
14891   jresult = result;
14892   return jresult;
14893 }
14894
14895
14896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14897   void * jresult ;
14898   Dali::Property::Array *result = 0 ;
14899
14900   {
14901     try {
14902       result = (Dali::Property::Array *)new Dali::Property::Array();
14903     } catch (std::out_of_range& e) {
14904       {
14905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14906       };
14907     } catch (std::exception& e) {
14908       {
14909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14910       };
14911     } catch (Dali::DaliException e) {
14912       {
14913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14914       };
14915     } catch (...) {
14916       {
14917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14918       };
14919     }
14920   }
14921
14922   jresult = (void *)result;
14923   return jresult;
14924 }
14925
14926
14927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14928   void * jresult ;
14929   Dali::Property::Array *arg1 = 0 ;
14930   Dali::Property::Array *result = 0 ;
14931
14932   arg1 = (Dali::Property::Array *)jarg1;
14933   if (!arg1) {
14934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14935     return 0;
14936   }
14937   {
14938     try {
14939       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14940     } catch (std::out_of_range& e) {
14941       {
14942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14943       };
14944     } catch (std::exception& e) {
14945       {
14946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14947       };
14948     } catch (Dali::DaliException e) {
14949       {
14950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14951       };
14952     } catch (...) {
14953       {
14954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14955       };
14956     }
14957   }
14958
14959   jresult = (void *)result;
14960   return jresult;
14961 }
14962
14963
14964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14965   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14966
14967   arg1 = (Dali::Property::Array *)jarg1;
14968   {
14969     try {
14970       delete arg1;
14971     } catch (std::out_of_range& e) {
14972       {
14973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14974       };
14975     } catch (std::exception& e) {
14976       {
14977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14978       };
14979     } catch (Dali::DaliException e) {
14980       {
14981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14982       };
14983     } catch (...) {
14984       {
14985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14986       };
14987     }
14988   }
14989
14990 }
14991
14992
14993 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14994   unsigned long jresult ;
14995   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14996   Dali::Property::Array::SizeType result;
14997
14998   arg1 = (Dali::Property::Array *)jarg1;
14999   {
15000     try {
15001       result = ((Dali::Property::Array const *)arg1)->Size();
15002     } catch (std::out_of_range& e) {
15003       {
15004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15005       };
15006     } catch (std::exception& e) {
15007       {
15008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15009       };
15010     } catch (Dali::DaliException e) {
15011       {
15012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15013       };
15014     } catch (...) {
15015       {
15016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15017       };
15018     }
15019   }
15020
15021   jresult = (unsigned long)result;
15022   return jresult;
15023 }
15024
15025
15026 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
15027   unsigned long jresult ;
15028   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15029   Dali::Property::Array::SizeType result;
15030
15031   arg1 = (Dali::Property::Array *)jarg1;
15032   {
15033     try {
15034       result = ((Dali::Property::Array const *)arg1)->Count();
15035     } catch (std::out_of_range& e) {
15036       {
15037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15038       };
15039     } catch (std::exception& e) {
15040       {
15041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15042       };
15043     } catch (Dali::DaliException e) {
15044       {
15045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15046       };
15047     } catch (...) {
15048       {
15049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15050       };
15051     }
15052   }
15053
15054   jresult = (unsigned long)result;
15055   return jresult;
15056 }
15057
15058
15059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15060   unsigned int jresult ;
15061   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15062   bool result;
15063
15064   arg1 = (Dali::Property::Array *)jarg1;
15065   {
15066     try {
15067       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15068     } catch (std::out_of_range& e) {
15069       {
15070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15071       };
15072     } catch (std::exception& e) {
15073       {
15074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15075       };
15076     } catch (Dali::DaliException e) {
15077       {
15078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15079       };
15080     } catch (...) {
15081       {
15082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15083       };
15084     }
15085   }
15086
15087   jresult = result;
15088   return jresult;
15089 }
15090
15091
15092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15093   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15094
15095   arg1 = (Dali::Property::Array *)jarg1;
15096   {
15097     try {
15098       (arg1)->Clear();
15099     } catch (std::out_of_range& e) {
15100       {
15101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15102       };
15103     } catch (std::exception& e) {
15104       {
15105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15106       };
15107     } catch (Dali::DaliException e) {
15108       {
15109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15110       };
15111     } catch (...) {
15112       {
15113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15114       };
15115     }
15116   }
15117
15118 }
15119
15120
15121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15122   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15123   Dali::Property::Array::SizeType arg2 ;
15124
15125   arg1 = (Dali::Property::Array *)jarg1;
15126   arg2 = (Dali::Property::Array::SizeType)jarg2;
15127   {
15128     try {
15129       (arg1)->Reserve(arg2);
15130     } catch (std::out_of_range& e) {
15131       {
15132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15133       };
15134     } catch (std::exception& e) {
15135       {
15136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15137       };
15138     } catch (Dali::DaliException e) {
15139       {
15140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15141       };
15142     } catch (...) {
15143       {
15144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15145       };
15146     }
15147   }
15148
15149 }
15150
15151
15152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15153   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15154   Dali::Property::Array::SizeType arg2 ;
15155
15156   arg1 = (Dali::Property::Array *)jarg1;
15157   arg2 = (Dali::Property::Array::SizeType)jarg2;
15158   {
15159     try {
15160       (arg1)->Resize(arg2);
15161     } catch (std::out_of_range& e) {
15162       {
15163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15164       };
15165     } catch (std::exception& e) {
15166       {
15167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15168       };
15169     } catch (Dali::DaliException e) {
15170       {
15171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15172       };
15173     } catch (...) {
15174       {
15175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15176       };
15177     }
15178   }
15179
15180 }
15181
15182
15183 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15184   unsigned long jresult ;
15185   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15186   Dali::Property::Array::SizeType result;
15187
15188   arg1 = (Dali::Property::Array *)jarg1;
15189   {
15190     try {
15191       result = (arg1)->Capacity();
15192     } catch (std::out_of_range& e) {
15193       {
15194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15195       };
15196     } catch (std::exception& e) {
15197       {
15198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15199       };
15200     } catch (Dali::DaliException e) {
15201       {
15202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15203       };
15204     } catch (...) {
15205       {
15206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15207       };
15208     }
15209   }
15210
15211   jresult = (unsigned long)result;
15212   return jresult;
15213 }
15214
15215
15216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15217   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15218   Dali::Property::Value *arg2 = 0 ;
15219
15220   arg1 = (Dali::Property::Array *)jarg1;
15221   arg2 = (Dali::Property::Value *)jarg2;
15222   if (!arg2) {
15223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15224     return ;
15225   }
15226   {
15227     try {
15228       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15229     } catch (std::out_of_range& e) {
15230       {
15231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15232       };
15233     } catch (std::exception& e) {
15234       {
15235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15236       };
15237     } catch (Dali::DaliException e) {
15238       {
15239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15240       };
15241     } catch (...) {
15242       {
15243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15244       };
15245     }
15246   }
15247
15248 }
15249
15250
15251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15252   void * jresult ;
15253   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15254   Dali::Property::Value *arg2 = 0 ;
15255   Dali::Property::Array *result = 0 ;
15256
15257   arg1 = (Dali::Property::Array *)jarg1;
15258   arg2 = (Dali::Property::Value *)jarg2;
15259   if (!arg2) {
15260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15261     return 0;
15262   }
15263   {
15264     try {
15265       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15266     } catch (std::out_of_range& e) {
15267       {
15268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15269       };
15270     } catch (std::exception& e) {
15271       {
15272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15273       };
15274     } catch (Dali::DaliException e) {
15275       {
15276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15277       };
15278     } catch (...) {
15279       {
15280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15281       };
15282     }
15283   }
15284
15285   jresult = (void *)result;
15286   return jresult;
15287 }
15288
15289
15290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15291   void * jresult ;
15292   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15293   Dali::Property::Array::SizeType arg2 ;
15294   Dali::Property::Value *result = 0 ;
15295
15296   arg1 = (Dali::Property::Array *)jarg1;
15297   arg2 = (Dali::Property::Array::SizeType)jarg2;
15298   {
15299     try {
15300       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15301     } catch (std::out_of_range& e) {
15302       {
15303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15304       };
15305     } catch (std::exception& e) {
15306       {
15307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15308       };
15309     } catch (Dali::DaliException e) {
15310       {
15311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15312       };
15313     } catch (...) {
15314       {
15315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15316       };
15317     }
15318   }
15319
15320   jresult = (void *)result;
15321   return jresult;
15322 }
15323
15324
15325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15326   void * jresult ;
15327   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15328   Dali::Property::Array::SizeType arg2 ;
15329   Dali::Property::Value *result = 0 ;
15330
15331   arg1 = (Dali::Property::Array *)jarg1;
15332   arg2 = (Dali::Property::Array::SizeType)jarg2;
15333   {
15334     try {
15335       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15336     } catch (std::out_of_range& e) {
15337       {
15338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15339       };
15340     } catch (std::exception& e) {
15341       {
15342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15343       };
15344     } catch (Dali::DaliException e) {
15345       {
15346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15347       };
15348     } catch (...) {
15349       {
15350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15351       };
15352     }
15353   }
15354
15355   jresult = (void *)result;
15356   return jresult;
15357 }
15358
15359
15360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15361   void * jresult ;
15362   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15363   Dali::Property::Array *arg2 = 0 ;
15364   Dali::Property::Array *result = 0 ;
15365
15366   arg1 = (Dali::Property::Array *)jarg1;
15367   arg2 = (Dali::Property::Array *)jarg2;
15368   if (!arg2) {
15369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15370     return 0;
15371   }
15372   {
15373     try {
15374       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15375     } catch (std::out_of_range& e) {
15376       {
15377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15378       };
15379     } catch (std::exception& e) {
15380       {
15381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15382       };
15383     } catch (Dali::DaliException e) {
15384       {
15385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15386       };
15387     } catch (...) {
15388       {
15389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15390       };
15391     }
15392   }
15393
15394   jresult = (void *)result;
15395   return jresult;
15396 }
15397
15398
15399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15400   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15401   enum Dali::Property::Key::Type arg2 ;
15402
15403   arg1 = (Dali::Property::Key *)jarg1;
15404   arg2 = (enum Dali::Property::Key::Type)jarg2;
15405   if (arg1) (arg1)->type = arg2;
15406 }
15407
15408
15409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15410   int jresult ;
15411   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15412   enum Dali::Property::Key::Type result;
15413
15414   arg1 = (Dali::Property::Key *)jarg1;
15415   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15416   jresult = (int)result;
15417   return jresult;
15418 }
15419
15420
15421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15422   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15423   Dali::Property::Index arg2 ;
15424
15425   arg1 = (Dali::Property::Key *)jarg1;
15426   arg2 = (Dali::Property::Index)jarg2;
15427   if (arg1) (arg1)->indexKey = arg2;
15428 }
15429
15430
15431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15432   int jresult ;
15433   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15434   Dali::Property::Index result;
15435
15436   arg1 = (Dali::Property::Key *)jarg1;
15437   result = (Dali::Property::Index) ((arg1)->indexKey);
15438   jresult = result;
15439   return jresult;
15440 }
15441
15442
15443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15444   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15445   std::string *arg2 = 0 ;
15446
15447   arg1 = (Dali::Property::Key *)jarg1;
15448   if (!jarg2) {
15449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15450     return ;
15451   }
15452   std::string arg2_str(jarg2);
15453   arg2 = &arg2_str;
15454   if (arg1) (arg1)->stringKey = *arg2;
15455
15456   //argout typemap for const std::string&
15457
15458 }
15459
15460
15461 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15462   char * jresult ;
15463   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15464   std::string *result = 0 ;
15465
15466   arg1 = (Dali::Property::Key *)jarg1;
15467   result = (std::string *) & ((arg1)->stringKey);
15468   jresult = SWIG_csharp_string_callback(result->c_str());
15469   return jresult;
15470 }
15471
15472
15473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15474   void * jresult ;
15475   std::string *arg1 = 0 ;
15476   Dali::Property::Key *result = 0 ;
15477
15478   if (!jarg1) {
15479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15480     return 0;
15481   }
15482   std::string arg1_str(jarg1);
15483   arg1 = &arg1_str;
15484   {
15485     try {
15486       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15487     } catch (std::out_of_range& e) {
15488       {
15489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15490       };
15491     } catch (std::exception& e) {
15492       {
15493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15494       };
15495     } catch (Dali::DaliException e) {
15496       {
15497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15498       };
15499     } catch (...) {
15500       {
15501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15502       };
15503     }
15504   }
15505
15506   jresult = (void *)result;
15507
15508   //argout typemap for const std::string&
15509
15510   return jresult;
15511 }
15512
15513
15514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15515   void * jresult ;
15516   Dali::Property::Index arg1 ;
15517   Dali::Property::Key *result = 0 ;
15518
15519   arg1 = (Dali::Property::Index)jarg1;
15520   {
15521     try {
15522       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15523     } catch (std::out_of_range& e) {
15524       {
15525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15526       };
15527     } catch (std::exception& e) {
15528       {
15529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15530       };
15531     } catch (Dali::DaliException e) {
15532       {
15533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15534       };
15535     } catch (...) {
15536       {
15537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15538       };
15539     }
15540   }
15541
15542   jresult = (void *)result;
15543   return jresult;
15544 }
15545
15546
15547 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15548   unsigned int jresult ;
15549   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15550   std::string *arg2 = 0 ;
15551   bool result;
15552
15553   arg1 = (Dali::Property::Key *)jarg1;
15554   if (!jarg2) {
15555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15556     return 0;
15557   }
15558   std::string arg2_str(jarg2);
15559   arg2 = &arg2_str;
15560   {
15561     try {
15562       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15563     } catch (std::out_of_range& e) {
15564       {
15565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15566       };
15567     } catch (std::exception& e) {
15568       {
15569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15570       };
15571     } catch (Dali::DaliException e) {
15572       {
15573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15574       };
15575     } catch (...) {
15576       {
15577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15578       };
15579     }
15580   }
15581
15582   jresult = result;
15583
15584   //argout typemap for const std::string&
15585
15586   return jresult;
15587 }
15588
15589
15590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15591   unsigned int jresult ;
15592   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15593   Dali::Property::Index arg2 ;
15594   bool result;
15595
15596   arg1 = (Dali::Property::Key *)jarg1;
15597   arg2 = (Dali::Property::Index)jarg2;
15598   {
15599     try {
15600       result = (bool)(arg1)->operator ==(arg2);
15601     } catch (std::out_of_range& e) {
15602       {
15603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15604       };
15605     } catch (std::exception& e) {
15606       {
15607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15608       };
15609     } catch (Dali::DaliException e) {
15610       {
15611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15612       };
15613     } catch (...) {
15614       {
15615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15616       };
15617     }
15618   }
15619
15620   jresult = result;
15621   return jresult;
15622 }
15623
15624
15625 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15626   unsigned int jresult ;
15627   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15628   Dali::Property::Key *arg2 = 0 ;
15629   bool result;
15630
15631   arg1 = (Dali::Property::Key *)jarg1;
15632   arg2 = (Dali::Property::Key *)jarg2;
15633   if (!arg2) {
15634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15635     return 0;
15636   }
15637   {
15638     try {
15639       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15640     } catch (std::out_of_range& e) {
15641       {
15642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15643       };
15644     } catch (std::exception& e) {
15645       {
15646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15647       };
15648     } catch (Dali::DaliException e) {
15649       {
15650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15651       };
15652     } catch (...) {
15653       {
15654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15655       };
15656     }
15657   }
15658
15659   jresult = result;
15660   return jresult;
15661 }
15662
15663
15664 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15665   unsigned int jresult ;
15666   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15667   std::string *arg2 = 0 ;
15668   bool result;
15669
15670   arg1 = (Dali::Property::Key *)jarg1;
15671   if (!jarg2) {
15672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15673     return 0;
15674   }
15675   std::string arg2_str(jarg2);
15676   arg2 = &arg2_str;
15677   {
15678     try {
15679       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15680     } catch (std::out_of_range& e) {
15681       {
15682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15683       };
15684     } catch (std::exception& e) {
15685       {
15686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15687       };
15688     } catch (Dali::DaliException e) {
15689       {
15690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15691       };
15692     } catch (...) {
15693       {
15694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15695       };
15696     }
15697   }
15698
15699   jresult = result;
15700
15701   //argout typemap for const std::string&
15702
15703   return jresult;
15704 }
15705
15706
15707 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15708   unsigned int jresult ;
15709   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15710   Dali::Property::Index arg2 ;
15711   bool result;
15712
15713   arg1 = (Dali::Property::Key *)jarg1;
15714   arg2 = (Dali::Property::Index)jarg2;
15715   {
15716     try {
15717       result = (bool)(arg1)->operator !=(arg2);
15718     } catch (std::out_of_range& e) {
15719       {
15720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15721       };
15722     } catch (std::exception& e) {
15723       {
15724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15725       };
15726     } catch (Dali::DaliException e) {
15727       {
15728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15729       };
15730     } catch (...) {
15731       {
15732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15733       };
15734     }
15735   }
15736
15737   jresult = result;
15738   return jresult;
15739 }
15740
15741
15742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15743   unsigned int jresult ;
15744   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15745   Dali::Property::Key *arg2 = 0 ;
15746   bool result;
15747
15748   arg1 = (Dali::Property::Key *)jarg1;
15749   arg2 = (Dali::Property::Key *)jarg2;
15750   if (!arg2) {
15751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15752     return 0;
15753   }
15754   {
15755     try {
15756       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15757     } catch (std::out_of_range& e) {
15758       {
15759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15760       };
15761     } catch (std::exception& e) {
15762       {
15763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15764       };
15765     } catch (Dali::DaliException e) {
15766       {
15767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15768       };
15769     } catch (...) {
15770       {
15771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15772       };
15773     }
15774   }
15775
15776   jresult = result;
15777   return jresult;
15778 }
15779
15780
15781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15782   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15783
15784   arg1 = (Dali::Property::Key *)jarg1;
15785   {
15786     try {
15787       delete arg1;
15788     } catch (std::out_of_range& e) {
15789       {
15790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15791       };
15792     } catch (std::exception& e) {
15793       {
15794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15795       };
15796     } catch (Dali::DaliException e) {
15797       {
15798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15799       };
15800     } catch (...) {
15801       {
15802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15803       };
15804     }
15805   }
15806
15807 }
15808
15809
15810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15811   void * jresult ;
15812   Dali::Property::Map *result = 0 ;
15813
15814   {
15815     try {
15816       result = (Dali::Property::Map *)new Dali::Property::Map();
15817     } catch (std::out_of_range& e) {
15818       {
15819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15820       };
15821     } catch (std::exception& e) {
15822       {
15823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15824       };
15825     } catch (Dali::DaliException e) {
15826       {
15827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15828       };
15829     } catch (...) {
15830       {
15831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15832       };
15833     }
15834   }
15835
15836   jresult = (void *)result;
15837   return jresult;
15838 }
15839
15840
15841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15842   void * jresult ;
15843   Dali::Property::Map *arg1 = 0 ;
15844   Dali::Property::Map *result = 0 ;
15845
15846   arg1 = (Dali::Property::Map *)jarg1;
15847   if (!arg1) {
15848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15849     return 0;
15850   }
15851   {
15852     try {
15853       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15854     } catch (std::out_of_range& e) {
15855       {
15856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15857       };
15858     } catch (std::exception& e) {
15859       {
15860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15861       };
15862     } catch (Dali::DaliException e) {
15863       {
15864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15865       };
15866     } catch (...) {
15867       {
15868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15869       };
15870     }
15871   }
15872
15873   jresult = (void *)result;
15874   return jresult;
15875 }
15876
15877
15878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15879   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15880
15881   arg1 = (Dali::Property::Map *)jarg1;
15882   {
15883     try {
15884       delete arg1;
15885     } catch (std::out_of_range& e) {
15886       {
15887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15888       };
15889     } catch (std::exception& e) {
15890       {
15891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15892       };
15893     } catch (Dali::DaliException e) {
15894       {
15895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15896       };
15897     } catch (...) {
15898       {
15899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15900       };
15901     }
15902   }
15903
15904 }
15905
15906
15907 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15908   unsigned long jresult ;
15909   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15910   Dali::Property::Map::SizeType result;
15911
15912   arg1 = (Dali::Property::Map *)jarg1;
15913   {
15914     try {
15915       result = ((Dali::Property::Map const *)arg1)->Count();
15916     } catch (std::out_of_range& e) {
15917       {
15918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15919       };
15920     } catch (std::exception& e) {
15921       {
15922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15923       };
15924     } catch (Dali::DaliException e) {
15925       {
15926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15927       };
15928     } catch (...) {
15929       {
15930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15931       };
15932     }
15933   }
15934
15935   jresult = (unsigned long)result;
15936   return jresult;
15937 }
15938
15939
15940 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15941   unsigned int jresult ;
15942   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15943   bool result;
15944
15945   arg1 = (Dali::Property::Map *)jarg1;
15946   {
15947     try {
15948       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15949     } catch (std::out_of_range& e) {
15950       {
15951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15952       };
15953     } catch (std::exception& e) {
15954       {
15955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15956       };
15957     } catch (Dali::DaliException e) {
15958       {
15959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15960       };
15961     } catch (...) {
15962       {
15963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15964       };
15965     }
15966   }
15967
15968   jresult = result;
15969   return jresult;
15970 }
15971
15972
15973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15974   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15975   char *arg2 = (char *) 0 ;
15976   Dali::Property::Value *arg3 = 0 ;
15977
15978   arg1 = (Dali::Property::Map *)jarg1;
15979   arg2 = (char *)jarg2;
15980   arg3 = (Dali::Property::Value *)jarg3;
15981   if (!arg3) {
15982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15983     return ;
15984   }
15985   {
15986     try {
15987       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15988     } catch (std::out_of_range& e) {
15989       {
15990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15991       };
15992     } catch (std::exception& e) {
15993       {
15994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15995       };
15996     } catch (Dali::DaliException e) {
15997       {
15998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15999       };
16000     } catch (...) {
16001       {
16002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16003       };
16004     }
16005   }
16006
16007 }
16008
16009
16010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16011   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16012   Dali::Property::Index arg2 ;
16013   Dali::Property::Value *arg3 = 0 ;
16014
16015   arg1 = (Dali::Property::Map *)jarg1;
16016   arg2 = (Dali::Property::Index)jarg2;
16017   arg3 = (Dali::Property::Value *)jarg3;
16018   if (!arg3) {
16019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16020     return ;
16021   }
16022   {
16023     try {
16024       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
16025     } catch (std::out_of_range& e) {
16026       {
16027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16028       };
16029     } catch (std::exception& e) {
16030       {
16031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16032       };
16033     } catch (Dali::DaliException e) {
16034       {
16035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16036       };
16037     } catch (...) {
16038       {
16039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16040       };
16041     }
16042   }
16043
16044 }
16045
16046
16047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
16048   void * jresult ;
16049   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16050   char *arg2 = (char *) 0 ;
16051   Dali::Property::Value *arg3 = 0 ;
16052   Dali::Property::Map *result = 0 ;
16053
16054   arg1 = (Dali::Property::Map *)jarg1;
16055   arg2 = (char *)jarg2;
16056   arg3 = (Dali::Property::Value *)jarg3;
16057   if (!arg3) {
16058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16059     return 0;
16060   }
16061   {
16062     try {
16063       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16064     } catch (std::out_of_range& e) {
16065       {
16066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16067       };
16068     } catch (std::exception& e) {
16069       {
16070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16071       };
16072     } catch (Dali::DaliException e) {
16073       {
16074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16075       };
16076     } catch (...) {
16077       {
16078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16079       };
16080     }
16081   }
16082
16083   jresult = (void *)result;
16084   return jresult;
16085 }
16086
16087
16088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16089   void * jresult ;
16090   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16091   Dali::Property::Index arg2 ;
16092   Dali::Property::Value *arg3 = 0 ;
16093   Dali::Property::Map *result = 0 ;
16094
16095   arg1 = (Dali::Property::Map *)jarg1;
16096   arg2 = (Dali::Property::Index)jarg2;
16097   arg3 = (Dali::Property::Value *)jarg3;
16098   if (!arg3) {
16099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16100     return 0;
16101   }
16102   {
16103     try {
16104       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16105     } catch (std::out_of_range& e) {
16106       {
16107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16108       };
16109     } catch (std::exception& e) {
16110       {
16111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16112       };
16113     } catch (Dali::DaliException e) {
16114       {
16115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16116       };
16117     } catch (...) {
16118       {
16119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16120       };
16121     }
16122   }
16123
16124   jresult = (void *)result;
16125   return jresult;
16126 }
16127
16128
16129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16130   void * jresult ;
16131   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16132   Dali::Property::Map::SizeType arg2 ;
16133   Dali::Property::Value *result = 0 ;
16134
16135   arg1 = (Dali::Property::Map *)jarg1;
16136   arg2 = (Dali::Property::Map::SizeType)jarg2;
16137   {
16138     try {
16139       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16140     } catch (std::out_of_range& e) {
16141       {
16142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16143       };
16144     } catch (std::exception& e) {
16145       {
16146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16147       };
16148     } catch (Dali::DaliException e) {
16149       {
16150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16151       };
16152     } catch (...) {
16153       {
16154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16155       };
16156     }
16157   }
16158
16159   jresult = (void *)result;
16160   return jresult;
16161 }
16162
16163
16164 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16165   char * jresult ;
16166   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16167   Dali::Property::Map::SizeType arg2 ;
16168   std::string *result = 0 ;
16169
16170   arg1 = (Dali::Property::Map *)jarg1;
16171   arg2 = (Dali::Property::Map::SizeType)jarg2;
16172   {
16173     try {
16174       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16175     } catch (std::out_of_range& e) {
16176       {
16177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16178       };
16179     } catch (std::exception& e) {
16180       {
16181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16182       };
16183     } catch (Dali::DaliException e) {
16184       {
16185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16186       };
16187     } catch (...) {
16188       {
16189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16190       };
16191     }
16192   }
16193
16194   jresult = SWIG_csharp_string_callback(result->c_str());
16195   return jresult;
16196 }
16197
16198
16199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16200   void * jresult ;
16201   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16202   Dali::Property::Map::SizeType arg2 ;
16203   SwigValueWrapper< Dali::Property::Key > result;
16204
16205   arg1 = (Dali::Property::Map *)jarg1;
16206   arg2 = (Dali::Property::Map::SizeType)jarg2;
16207   {
16208     try {
16209       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16210     } catch (std::out_of_range& e) {
16211       {
16212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16213       };
16214     } catch (std::exception& e) {
16215       {
16216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16217       };
16218     } catch (Dali::DaliException e) {
16219       {
16220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16221       };
16222     } catch (...) {
16223       {
16224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16225       };
16226     }
16227   }
16228
16229   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16230   return jresult;
16231 }
16232
16233
16234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16235   void * jresult ;
16236   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16237   Dali::Property::Map::SizeType arg2 ;
16238   StringValuePair *result = 0 ;
16239
16240   arg1 = (Dali::Property::Map *)jarg1;
16241   arg2 = (Dali::Property::Map::SizeType)jarg2;
16242   {
16243     try {
16244       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16245     } catch (std::out_of_range& e) {
16246       {
16247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16248       };
16249     } catch (std::exception& e) {
16250       {
16251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16252       };
16253     } catch (Dali::DaliException e) {
16254       {
16255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16256       };
16257     } catch (...) {
16258       {
16259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16260       };
16261     }
16262   }
16263
16264   jresult = (void *)result;
16265   return jresult;
16266 }
16267
16268
16269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16270   void * jresult ;
16271   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16272   char *arg2 = (char *) 0 ;
16273   Dali::Property::Value *result = 0 ;
16274
16275   arg1 = (Dali::Property::Map *)jarg1;
16276   arg2 = (char *)jarg2;
16277   {
16278     try {
16279       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16280     } catch (std::out_of_range& e) {
16281       {
16282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16283       };
16284     } catch (std::exception& e) {
16285       {
16286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16287       };
16288     } catch (Dali::DaliException e) {
16289       {
16290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16291       };
16292     } catch (...) {
16293       {
16294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16295       };
16296     }
16297   }
16298
16299   jresult = (void *)result;
16300   return jresult;
16301 }
16302
16303
16304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16305   void * jresult ;
16306   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16307   Dali::Property::Index arg2 ;
16308   Dali::Property::Value *result = 0 ;
16309
16310   arg1 = (Dali::Property::Map *)jarg1;
16311   arg2 = (Dali::Property::Index)jarg2;
16312   {
16313     try {
16314       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16315     } catch (std::out_of_range& e) {
16316       {
16317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16318       };
16319     } catch (std::exception& e) {
16320       {
16321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16322       };
16323     } catch (Dali::DaliException e) {
16324       {
16325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16326       };
16327     } catch (...) {
16328       {
16329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16330       };
16331     }
16332   }
16333
16334   jresult = (void *)result;
16335   return jresult;
16336 }
16337
16338
16339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16340   void * jresult ;
16341   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16342   Dali::Property::Index arg2 ;
16343   std::string *arg3 = 0 ;
16344   Dali::Property::Value *result = 0 ;
16345
16346   arg1 = (Dali::Property::Map *)jarg1;
16347   arg2 = (Dali::Property::Index)jarg2;
16348   if (!jarg3) {
16349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16350     return 0;
16351   }
16352   std::string arg3_str(jarg3);
16353   arg3 = &arg3_str;
16354   {
16355     try {
16356       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16357     } catch (std::out_of_range& e) {
16358       {
16359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16360       };
16361     } catch (std::exception& e) {
16362       {
16363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16364       };
16365     } catch (Dali::DaliException e) {
16366       {
16367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16368       };
16369     } catch (...) {
16370       {
16371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16372       };
16373     }
16374   }
16375
16376   jresult = (void *)result;
16377
16378   //argout typemap for const std::string&
16379
16380   return jresult;
16381 }
16382
16383
16384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16385   void * jresult ;
16386   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16387   std::string *arg2 = 0 ;
16388   Dali::Property::Type arg3 ;
16389   Dali::Property::Value *result = 0 ;
16390
16391   arg1 = (Dali::Property::Map *)jarg1;
16392   if (!jarg2) {
16393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16394     return 0;
16395   }
16396   std::string arg2_str(jarg2);
16397   arg2 = &arg2_str;
16398   arg3 = (Dali::Property::Type)jarg3;
16399   {
16400     try {
16401       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16402     } catch (std::out_of_range& e) {
16403       {
16404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16405       };
16406     } catch (std::exception& e) {
16407       {
16408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16409       };
16410     } catch (Dali::DaliException e) {
16411       {
16412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16413       };
16414     } catch (...) {
16415       {
16416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16417       };
16418     }
16419   }
16420
16421   jresult = (void *)result;
16422
16423   //argout typemap for const std::string&
16424
16425   return jresult;
16426 }
16427
16428
16429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16430   void * jresult ;
16431   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16432   Dali::Property::Index arg2 ;
16433   Dali::Property::Type arg3 ;
16434   Dali::Property::Value *result = 0 ;
16435
16436   arg1 = (Dali::Property::Map *)jarg1;
16437   arg2 = (Dali::Property::Index)jarg2;
16438   arg3 = (Dali::Property::Type)jarg3;
16439   {
16440     try {
16441       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16442     } catch (std::out_of_range& e) {
16443       {
16444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16445       };
16446     } catch (std::exception& e) {
16447       {
16448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16449       };
16450     } catch (Dali::DaliException e) {
16451       {
16452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16453       };
16454     } catch (...) {
16455       {
16456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16457       };
16458     }
16459   }
16460
16461   jresult = (void *)result;
16462   return jresult;
16463 }
16464
16465
16466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16467   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16468
16469   arg1 = (Dali::Property::Map *)jarg1;
16470   {
16471     try {
16472       (arg1)->Clear();
16473     } catch (std::out_of_range& e) {
16474       {
16475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16476       };
16477     } catch (std::exception& e) {
16478       {
16479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16480       };
16481     } catch (Dali::DaliException e) {
16482       {
16483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16484       };
16485     } catch (...) {
16486       {
16487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16488       };
16489     }
16490   }
16491
16492 }
16493
16494
16495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16496   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16497   Dali::Property::Map *arg2 = 0 ;
16498
16499   arg1 = (Dali::Property::Map *)jarg1;
16500   arg2 = (Dali::Property::Map *)jarg2;
16501   if (!arg2) {
16502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16503     return ;
16504   }
16505   {
16506     try {
16507       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16508     } catch (std::out_of_range& e) {
16509       {
16510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16511       };
16512     } catch (std::exception& e) {
16513       {
16514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16515       };
16516     } catch (Dali::DaliException e) {
16517       {
16518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16519       };
16520     } catch (...) {
16521       {
16522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16523       };
16524     }
16525   }
16526
16527 }
16528
16529
16530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16531   void * jresult ;
16532   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16533   std::string *arg2 = 0 ;
16534   Dali::Property::Value *result = 0 ;
16535
16536   arg1 = (Dali::Property::Map *)jarg1;
16537   if (!jarg2) {
16538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16539     return 0;
16540   }
16541   std::string arg2_str(jarg2);
16542   arg2 = &arg2_str;
16543   {
16544     try {
16545       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16546     } catch (std::out_of_range& e) {
16547       {
16548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16549       };
16550     } catch (std::exception& e) {
16551       {
16552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16553       };
16554     } catch (Dali::DaliException e) {
16555       {
16556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16557       };
16558     } catch (...) {
16559       {
16560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16561       };
16562     }
16563   }
16564
16565   jresult = (void *)result;
16566
16567   //argout typemap for const std::string&
16568
16569   return jresult;
16570 }
16571
16572
16573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16574   void * jresult ;
16575   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16576   Dali::Property::Index arg2 ;
16577   Dali::Property::Value *result = 0 ;
16578
16579   arg1 = (Dali::Property::Map *)jarg1;
16580   arg2 = (Dali::Property::Index)jarg2;
16581   {
16582     try {
16583       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16584     } catch (std::out_of_range& e) {
16585       {
16586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16587       };
16588     } catch (std::exception& e) {
16589       {
16590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16591       };
16592     } catch (Dali::DaliException e) {
16593       {
16594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16595       };
16596     } catch (...) {
16597       {
16598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16599       };
16600     }
16601   }
16602
16603   jresult = (void *)result;
16604   return jresult;
16605 }
16606
16607
16608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16609   void * jresult ;
16610   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16611   Dali::Property::Map *arg2 = 0 ;
16612   Dali::Property::Map *result = 0 ;
16613
16614   arg1 = (Dali::Property::Map *)jarg1;
16615   arg2 = (Dali::Property::Map *)jarg2;
16616   if (!arg2) {
16617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16618     return 0;
16619   }
16620   {
16621     try {
16622       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16623     } catch (std::out_of_range& e) {
16624       {
16625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16626       };
16627     } catch (std::exception& e) {
16628       {
16629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16630       };
16631     } catch (Dali::DaliException e) {
16632       {
16633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16634       };
16635     } catch (...) {
16636       {
16637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16638       };
16639     }
16640   }
16641
16642   jresult = (void *)result;
16643   return jresult;
16644 }
16645
16646
16647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey(void* jarg1, char* jarg2, void* jarg3) {
16648
16649   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16650
16651   if (!jarg2) {
16652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16653     return;
16654   }
16655   std::string arg2_str(jarg2);
16656   std::string* arg2 = &arg2_str;
16657
16658   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16659
16660   {
16661     try {
16662       arg1->operator[]((std::string const &)*arg2) = *arg3;
16663     } catch (std::out_of_range& e) {
16664       {
16665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16666       };
16667     } catch (std::exception& e) {
16668       {
16669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16670       };
16671     } catch (Dali::DaliException e) {
16672       {
16673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16674       };
16675     } catch (...) {
16676       {
16677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16678       };
16679     }
16680   }
16681 }
16682
16683
16684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey(void* jarg1, int jarg2, void* jarg3) {
16685
16686   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16687   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
16688   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16689
16690   {
16691     try {
16692       arg1->operator[](arg2) = *arg3;
16693     } catch (std::out_of_range& e) {
16694       {
16695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16696       };
16697     } catch (std::exception& e) {
16698       {
16699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16700       };
16701     } catch (Dali::DaliException e) {
16702       {
16703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16704       };
16705     } catch (...) {
16706       {
16707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16708       };
16709     }
16710   }
16711 }
16712
16713
16714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16715   void * jresult ;
16716   Dali::Property::Value *result = 0 ;
16717
16718   {
16719     try {
16720       result = (Dali::Property::Value *)new Dali::Property::Value();
16721     } catch (std::out_of_range& e) {
16722       {
16723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16724       };
16725     } catch (std::exception& e) {
16726       {
16727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16728       };
16729     } catch (Dali::DaliException e) {
16730       {
16731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16732       };
16733     } catch (...) {
16734       {
16735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16736       };
16737     }
16738   }
16739
16740   jresult = (void *)result;
16741   return jresult;
16742 }
16743
16744
16745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16746   void * jresult ;
16747   bool arg1 ;
16748   Dali::Property::Value *result = 0 ;
16749
16750   arg1 = jarg1 ? true : false;
16751   {
16752     try {
16753       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16754     } catch (std::out_of_range& e) {
16755       {
16756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16757       };
16758     } catch (std::exception& e) {
16759       {
16760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16761       };
16762     } catch (Dali::DaliException e) {
16763       {
16764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16765       };
16766     } catch (...) {
16767       {
16768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16769       };
16770     }
16771   }
16772
16773   jresult = (void *)result;
16774   return jresult;
16775 }
16776
16777
16778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16779   void * jresult ;
16780   int arg1 ;
16781   Dali::Property::Value *result = 0 ;
16782
16783   arg1 = (int)jarg1;
16784   {
16785     try {
16786       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16787     } catch (std::out_of_range& e) {
16788       {
16789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16790       };
16791     } catch (std::exception& e) {
16792       {
16793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16794       };
16795     } catch (Dali::DaliException e) {
16796       {
16797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16798       };
16799     } catch (...) {
16800       {
16801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16802       };
16803     }
16804   }
16805
16806   jresult = (void *)result;
16807   return jresult;
16808 }
16809
16810
16811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16812   void * jresult ;
16813   float arg1 ;
16814   Dali::Property::Value *result = 0 ;
16815
16816   arg1 = (float)jarg1;
16817   {
16818     try {
16819       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16820     } catch (std::out_of_range& e) {
16821       {
16822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16823       };
16824     } catch (std::exception& e) {
16825       {
16826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16827       };
16828     } catch (Dali::DaliException e) {
16829       {
16830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16831       };
16832     } catch (...) {
16833       {
16834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16835       };
16836     }
16837   }
16838
16839   jresult = (void *)result;
16840   return jresult;
16841 }
16842
16843
16844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16845   void * jresult ;
16846   Dali::Vector2 *arg1 = 0 ;
16847   Dali::Property::Value *result = 0 ;
16848
16849   arg1 = (Dali::Vector2 *)jarg1;
16850   if (!arg1) {
16851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16852     return 0;
16853   }
16854   {
16855     try {
16856       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16857     } catch (std::out_of_range& e) {
16858       {
16859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16860       };
16861     } catch (std::exception& e) {
16862       {
16863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16864       };
16865     } catch (Dali::DaliException e) {
16866       {
16867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16868       };
16869     } catch (...) {
16870       {
16871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16872       };
16873     }
16874   }
16875
16876   jresult = (void *)result;
16877   return jresult;
16878 }
16879
16880
16881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16882   void * jresult ;
16883   Dali::Vector3 *arg1 = 0 ;
16884   Dali::Property::Value *result = 0 ;
16885
16886   arg1 = (Dali::Vector3 *)jarg1;
16887   if (!arg1) {
16888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16889     return 0;
16890   }
16891   {
16892     try {
16893       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16894     } catch (std::out_of_range& e) {
16895       {
16896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16897       };
16898     } catch (std::exception& e) {
16899       {
16900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16901       };
16902     } catch (Dali::DaliException e) {
16903       {
16904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16905       };
16906     } catch (...) {
16907       {
16908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16909       };
16910     }
16911   }
16912
16913   jresult = (void *)result;
16914   return jresult;
16915 }
16916
16917
16918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16919   void * jresult ;
16920   Dali::Vector4 *arg1 = 0 ;
16921   Dali::Property::Value *result = 0 ;
16922
16923   arg1 = (Dali::Vector4 *)jarg1;
16924   if (!arg1) {
16925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16926     return 0;
16927   }
16928   {
16929     try {
16930       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16931     } catch (std::out_of_range& e) {
16932       {
16933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16934       };
16935     } catch (std::exception& e) {
16936       {
16937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16938       };
16939     } catch (Dali::DaliException e) {
16940       {
16941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16942       };
16943     } catch (...) {
16944       {
16945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16946       };
16947     }
16948   }
16949
16950   jresult = (void *)result;
16951   return jresult;
16952 }
16953
16954
16955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16956   void * jresult ;
16957   Dali::Matrix3 *arg1 = 0 ;
16958   Dali::Property::Value *result = 0 ;
16959
16960   arg1 = (Dali::Matrix3 *)jarg1;
16961   if (!arg1) {
16962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16963     return 0;
16964   }
16965   {
16966     try {
16967       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16968     } catch (std::out_of_range& e) {
16969       {
16970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16971       };
16972     } catch (std::exception& e) {
16973       {
16974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16975       };
16976     } catch (Dali::DaliException e) {
16977       {
16978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16979       };
16980     } catch (...) {
16981       {
16982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16983       };
16984     }
16985   }
16986
16987   jresult = (void *)result;
16988   return jresult;
16989 }
16990
16991
16992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16993   void * jresult ;
16994   Dali::Matrix *arg1 = 0 ;
16995   Dali::Property::Value *result = 0 ;
16996
16997   arg1 = (Dali::Matrix *)jarg1;
16998   if (!arg1) {
16999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
17000     return 0;
17001   }
17002   {
17003     try {
17004       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
17005     } catch (std::out_of_range& e) {
17006       {
17007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17008       };
17009     } catch (std::exception& e) {
17010       {
17011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17012       };
17013     } catch (Dali::DaliException e) {
17014       {
17015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17016       };
17017     } catch (...) {
17018       {
17019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17020       };
17021     }
17022   }
17023
17024   jresult = (void *)result;
17025   return jresult;
17026 }
17027
17028
17029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
17030   void * jresult ;
17031   Dali::Rect< int > *arg1 = 0 ;
17032   Dali::Property::Value *result = 0 ;
17033
17034   arg1 = (Dali::Rect< int > *)jarg1;
17035   if (!arg1) {
17036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
17037     return 0;
17038   }
17039   {
17040     try {
17041       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
17042     } catch (std::out_of_range& e) {
17043       {
17044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17045       };
17046     } catch (std::exception& e) {
17047       {
17048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17049       };
17050     } catch (Dali::DaliException e) {
17051       {
17052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17053       };
17054     } catch (...) {
17055       {
17056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17057       };
17058     }
17059   }
17060
17061   jresult = (void *)result;
17062   return jresult;
17063 }
17064
17065
17066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
17067   void * jresult ;
17068   Dali::AngleAxis *arg1 = 0 ;
17069   Dali::Property::Value *result = 0 ;
17070
17071   arg1 = (Dali::AngleAxis *)jarg1;
17072   if (!arg1) {
17073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17074     return 0;
17075   }
17076   {
17077     try {
17078       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17079     } catch (std::out_of_range& e) {
17080       {
17081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17082       };
17083     } catch (std::exception& e) {
17084       {
17085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17086       };
17087     } catch (Dali::DaliException e) {
17088       {
17089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17090       };
17091     } catch (...) {
17092       {
17093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17094       };
17095     }
17096   }
17097
17098   jresult = (void *)result;
17099   return jresult;
17100 }
17101
17102
17103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17104   void * jresult ;
17105   Dali::Quaternion *arg1 = 0 ;
17106   Dali::Property::Value *result = 0 ;
17107
17108   arg1 = (Dali::Quaternion *)jarg1;
17109   if (!arg1) {
17110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17111     return 0;
17112   }
17113   {
17114     try {
17115       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17116     } catch (std::out_of_range& e) {
17117       {
17118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17119       };
17120     } catch (std::exception& e) {
17121       {
17122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17123       };
17124     } catch (Dali::DaliException e) {
17125       {
17126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17127       };
17128     } catch (...) {
17129       {
17130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17131       };
17132     }
17133   }
17134
17135   jresult = (void *)result;
17136   return jresult;
17137 }
17138
17139
17140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17141   void * jresult ;
17142   std::string *arg1 = 0 ;
17143   Dali::Property::Value *result = 0 ;
17144
17145   if (!jarg1) {
17146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17147     return 0;
17148   }
17149   std::string arg1_str(jarg1);
17150   arg1 = &arg1_str;
17151   {
17152     try {
17153       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17154     } catch (std::out_of_range& e) {
17155       {
17156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17157       };
17158     } catch (std::exception& e) {
17159       {
17160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17161       };
17162     } catch (Dali::DaliException e) {
17163       {
17164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17165       };
17166     } catch (...) {
17167       {
17168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17169       };
17170     }
17171   }
17172
17173   jresult = (void *)result;
17174
17175   //argout typemap for const std::string&
17176
17177   return jresult;
17178 }
17179
17180
17181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17182   void * jresult ;
17183   Dali::Property::Array *arg1 = 0 ;
17184   Dali::Property::Value *result = 0 ;
17185
17186   arg1 = (Dali::Property::Array *)jarg1;
17187   if (!arg1) {
17188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17189     return 0;
17190   }
17191   {
17192     try {
17193       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17194     } catch (std::out_of_range& e) {
17195       {
17196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17197       };
17198     } catch (std::exception& e) {
17199       {
17200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17201       };
17202     } catch (Dali::DaliException e) {
17203       {
17204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17205       };
17206     } catch (...) {
17207       {
17208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17209       };
17210     }
17211   }
17212
17213   jresult = (void *)result;
17214   return jresult;
17215 }
17216
17217
17218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17219   void * jresult ;
17220   Dali::Property::Map *arg1 = 0 ;
17221   Dali::Property::Value *result = 0 ;
17222
17223   arg1 = (Dali::Property::Map *)jarg1;
17224   if (!arg1) {
17225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17226     return 0;
17227   }
17228   {
17229     try {
17230       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17231     } catch (std::out_of_range& e) {
17232       {
17233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17234       };
17235     } catch (std::exception& e) {
17236       {
17237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17238       };
17239     } catch (Dali::DaliException e) {
17240       {
17241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17242       };
17243     } catch (...) {
17244       {
17245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17246       };
17247     }
17248   }
17249
17250   jresult = (void *)result;
17251   return jresult;
17252 }
17253
17254
17255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17256   void * jresult ;
17257   Extents *arg1 = 0 ;
17258   Dali::Property::Value *result = 0 ;
17259
17260   arg1 = (Extents *)jarg1;
17261   if (!arg1) {
17262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17263     return 0;
17264   }
17265   {
17266     try {
17267       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17268     } catch (std::out_of_range& e) {
17269       {
17270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17271       };
17272     } catch (std::exception& e) {
17273       {
17274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17275       };
17276     } catch (...) {
17277       {
17278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17279       };
17280     }
17281   }
17282   jresult = (void *)result;
17283   return jresult;
17284 }
17285
17286
17287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17288   void * jresult ;
17289   Dali::Property::Type arg1 ;
17290   Dali::Property::Value *result = 0 ;
17291
17292   arg1 = (Dali::Property::Type)jarg1;
17293   {
17294     try {
17295       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17296     } catch (std::out_of_range& e) {
17297       {
17298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17299       };
17300     } catch (std::exception& e) {
17301       {
17302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17303       };
17304     } catch (Dali::DaliException e) {
17305       {
17306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17307       };
17308     } catch (...) {
17309       {
17310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17311       };
17312     }
17313   }
17314
17315   jresult = (void *)result;
17316   return jresult;
17317 }
17318
17319
17320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17321   void * jresult ;
17322   Dali::Property::Value *arg1 = 0 ;
17323   Dali::Property::Value *result = 0 ;
17324
17325   arg1 = (Dali::Property::Value *)jarg1;
17326   if (!arg1) {
17327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17328     return 0;
17329   }
17330   {
17331     try {
17332       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17333     } catch (std::out_of_range& e) {
17334       {
17335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17336       };
17337     } catch (std::exception& e) {
17338       {
17339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17340       };
17341     } catch (Dali::DaliException e) {
17342       {
17343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17344       };
17345     } catch (...) {
17346       {
17347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17348       };
17349     }
17350   }
17351
17352   jresult = (void *)result;
17353   return jresult;
17354 }
17355
17356
17357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17358   void * jresult ;
17359   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17360   Dali::Property::Value *arg2 = 0 ;
17361   Dali::Property::Value *result = 0 ;
17362
17363   arg1 = (Dali::Property::Value *)jarg1;
17364   arg2 = (Dali::Property::Value *)jarg2;
17365   if (!arg2) {
17366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17367     return 0;
17368   }
17369   {
17370     try {
17371       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17372     } catch (std::out_of_range& e) {
17373       {
17374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17375       };
17376     } catch (std::exception& e) {
17377       {
17378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17379       };
17380     } catch (Dali::DaliException e) {
17381       {
17382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17383       };
17384     } catch (...) {
17385       {
17386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17387       };
17388     }
17389   }
17390
17391   jresult = (void *)result;
17392   return jresult;
17393 }
17394
17395
17396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17397   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17398
17399   arg1 = (Dali::Property::Value *)jarg1;
17400   {
17401     try {
17402       delete arg1;
17403     } catch (std::out_of_range& e) {
17404       {
17405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17406       };
17407     } catch (std::exception& e) {
17408       {
17409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17410       };
17411     } catch (Dali::DaliException e) {
17412       {
17413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17414       };
17415     } catch (...) {
17416       {
17417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17418       };
17419     }
17420   }
17421
17422 }
17423
17424
17425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17426   int jresult ;
17427   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17428   Dali::Property::Type result;
17429
17430   arg1 = (Dali::Property::Value *)jarg1;
17431   {
17432     try {
17433       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17434     } catch (std::out_of_range& e) {
17435       {
17436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17437       };
17438     } catch (std::exception& e) {
17439       {
17440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17441       };
17442     } catch (Dali::DaliException e) {
17443       {
17444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17445       };
17446     } catch (...) {
17447       {
17448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17449       };
17450     }
17451   }
17452
17453   jresult = (int)result;
17454   return jresult;
17455 }
17456
17457
17458 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17459   unsigned int jresult ;
17460   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17461   bool *arg2 = 0 ;
17462   bool result;
17463
17464   arg1 = (Dali::Property::Value *)jarg1;
17465   arg2 = (bool *)jarg2;
17466   {
17467     try {
17468       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17469     } catch (std::out_of_range& e) {
17470       {
17471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17472       };
17473     } catch (std::exception& e) {
17474       {
17475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17476       };
17477     } catch (Dali::DaliException e) {
17478       {
17479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17480       };
17481     } catch (...) {
17482       {
17483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17484       };
17485     }
17486   }
17487
17488   jresult = result;
17489   return jresult;
17490 }
17491
17492
17493 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17494   unsigned int jresult ;
17495   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17496   float *arg2 = 0 ;
17497   bool result;
17498
17499   arg1 = (Dali::Property::Value *)jarg1;
17500   arg2 = (float *)jarg2;
17501   {
17502     try {
17503       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17504     } catch (std::out_of_range& e) {
17505       {
17506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17507       };
17508     } catch (std::exception& e) {
17509       {
17510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17511       };
17512     } catch (Dali::DaliException e) {
17513       {
17514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17515       };
17516     } catch (...) {
17517       {
17518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17519       };
17520     }
17521   }
17522
17523   jresult = result;
17524   return jresult;
17525 }
17526
17527
17528 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17529   unsigned int jresult ;
17530   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17531   int *arg2 = 0 ;
17532   bool result;
17533
17534   arg1 = (Dali::Property::Value *)jarg1;
17535   arg2 = (int *)jarg2;
17536   {
17537     try {
17538       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17539     } catch (std::out_of_range& e) {
17540       {
17541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17542       };
17543     } catch (std::exception& e) {
17544       {
17545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17546       };
17547     } catch (Dali::DaliException e) {
17548       {
17549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17550       };
17551     } catch (...) {
17552       {
17553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17554       };
17555     }
17556   }
17557
17558   jresult = result;
17559   return jresult;
17560 }
17561
17562
17563 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17564   unsigned int jresult ;
17565   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17566   Dali::Rect< int > *arg2 = 0 ;
17567   bool result;
17568
17569   arg1 = (Dali::Property::Value *)jarg1;
17570   arg2 = (Dali::Rect< int > *)jarg2;
17571   if (!arg2) {
17572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17573     return 0;
17574   }
17575   {
17576     try {
17577       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17578     } catch (std::out_of_range& e) {
17579       {
17580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17581       };
17582     } catch (std::exception& e) {
17583       {
17584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17585       };
17586     } catch (Dali::DaliException e) {
17587       {
17588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17589       };
17590     } catch (...) {
17591       {
17592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17593       };
17594     }
17595   }
17596
17597   jresult = result;
17598   return jresult;
17599 }
17600
17601
17602 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17603   unsigned int jresult ;
17604   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17605   Dali::Vector2 *arg2 = 0 ;
17606   bool result;
17607
17608   arg1 = (Dali::Property::Value *)jarg1;
17609   arg2 = (Dali::Vector2 *)jarg2;
17610   if (!arg2) {
17611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17612     return 0;
17613   }
17614   {
17615     try {
17616       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17617     } catch (std::out_of_range& e) {
17618       {
17619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17620       };
17621     } catch (std::exception& e) {
17622       {
17623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17624       };
17625     } catch (Dali::DaliException e) {
17626       {
17627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17628       };
17629     } catch (...) {
17630       {
17631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17632       };
17633     }
17634   }
17635
17636   jresult = result;
17637   return jresult;
17638 }
17639
17640
17641 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17642   unsigned int jresult ;
17643   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17644   Dali::Vector3 *arg2 = 0 ;
17645   bool result;
17646
17647   arg1 = (Dali::Property::Value *)jarg1;
17648   arg2 = (Dali::Vector3 *)jarg2;
17649   if (!arg2) {
17650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17651     return 0;
17652   }
17653   {
17654     try {
17655       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17656     } catch (std::out_of_range& e) {
17657       {
17658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17659       };
17660     } catch (std::exception& e) {
17661       {
17662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17663       };
17664     } catch (Dali::DaliException e) {
17665       {
17666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17667       };
17668     } catch (...) {
17669       {
17670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17671       };
17672     }
17673   }
17674
17675   jresult = result;
17676   return jresult;
17677 }
17678
17679
17680 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17681   unsigned int jresult ;
17682   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17683   Dali::Vector4 *arg2 = 0 ;
17684   bool result;
17685
17686   arg1 = (Dali::Property::Value *)jarg1;
17687   arg2 = (Dali::Vector4 *)jarg2;
17688   if (!arg2) {
17689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17690     return 0;
17691   }
17692   {
17693     try {
17694       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17695     } catch (std::out_of_range& e) {
17696       {
17697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17698       };
17699     } catch (std::exception& e) {
17700       {
17701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17702       };
17703     } catch (Dali::DaliException e) {
17704       {
17705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17706       };
17707     } catch (...) {
17708       {
17709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17710       };
17711     }
17712   }
17713
17714   jresult = result;
17715   return jresult;
17716 }
17717
17718
17719 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17720   unsigned int jresult ;
17721   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17722   Dali::Matrix3 *arg2 = 0 ;
17723   bool result;
17724
17725   arg1 = (Dali::Property::Value *)jarg1;
17726   arg2 = (Dali::Matrix3 *)jarg2;
17727   if (!arg2) {
17728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17729     return 0;
17730   }
17731   {
17732     try {
17733       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17734     } catch (std::out_of_range& e) {
17735       {
17736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17737       };
17738     } catch (std::exception& e) {
17739       {
17740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17741       };
17742     } catch (Dali::DaliException e) {
17743       {
17744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17745       };
17746     } catch (...) {
17747       {
17748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17749       };
17750     }
17751   }
17752
17753   jresult = result;
17754   return jresult;
17755 }
17756
17757
17758 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17759   unsigned int jresult ;
17760   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17761   Dali::Matrix *arg2 = 0 ;
17762   bool result;
17763
17764   arg1 = (Dali::Property::Value *)jarg1;
17765   arg2 = (Dali::Matrix *)jarg2;
17766   if (!arg2) {
17767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17768     return 0;
17769   }
17770   {
17771     try {
17772       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17773     } catch (std::out_of_range& e) {
17774       {
17775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17776       };
17777     } catch (std::exception& e) {
17778       {
17779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17780       };
17781     } catch (Dali::DaliException e) {
17782       {
17783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17784       };
17785     } catch (...) {
17786       {
17787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17788       };
17789     }
17790   }
17791
17792   jresult = result;
17793   return jresult;
17794 }
17795
17796
17797 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17798   unsigned int jresult ;
17799   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17800   Dali::AngleAxis *arg2 = 0 ;
17801   bool result;
17802
17803   arg1 = (Dali::Property::Value *)jarg1;
17804   arg2 = (Dali::AngleAxis *)jarg2;
17805   if (!arg2) {
17806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17807     return 0;
17808   }
17809   {
17810     try {
17811       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17812     } catch (std::out_of_range& e) {
17813       {
17814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17815       };
17816     } catch (std::exception& e) {
17817       {
17818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17819       };
17820     } catch (Dali::DaliException e) {
17821       {
17822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17823       };
17824     } catch (...) {
17825       {
17826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17827       };
17828     }
17829   }
17830
17831   jresult = result;
17832   return jresult;
17833 }
17834
17835
17836 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17837   unsigned int jresult ;
17838   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17839   Dali::Quaternion *arg2 = 0 ;
17840   bool result;
17841
17842   arg1 = (Dali::Property::Value *)jarg1;
17843   arg2 = (Dali::Quaternion *)jarg2;
17844   if (!arg2) {
17845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17846     return 0;
17847   }
17848   {
17849     try {
17850       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17851     } catch (std::out_of_range& e) {
17852       {
17853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17854       };
17855     } catch (std::exception& e) {
17856       {
17857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17858       };
17859     } catch (Dali::DaliException e) {
17860       {
17861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17862       };
17863     } catch (...) {
17864       {
17865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17866       };
17867     }
17868   }
17869
17870   jresult = result;
17871   return jresult;
17872 }
17873
17874
17875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17876   unsigned int jresult ;
17877   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17878   std::string *arg2 = 0 ;
17879   bool result;
17880
17881   arg1 = (Dali::Property::Value *)jarg1;
17882
17883   //typemap in
17884   std::string temp;
17885   arg2 = &temp;
17886
17887   {
17888     try {
17889       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17890     } catch (std::out_of_range& e) {
17891       {
17892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17893       };
17894     } catch (std::exception& e) {
17895       {
17896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17897       };
17898     } catch (Dali::DaliException e) {
17899       {
17900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17901       };
17902     } catch (...) {
17903       {
17904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17905       };
17906     }
17907   }
17908
17909   jresult = result;
17910
17911   //Typemap argout in c++ file.
17912   //This will convert c++ string to c# string
17913   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17914
17915   return jresult;
17916 }
17917
17918
17919 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17920   unsigned int jresult ;
17921   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17922   Dali::Property::Array *arg2 = 0 ;
17923   bool result;
17924
17925   arg1 = (Dali::Property::Value *)jarg1;
17926   arg2 = (Dali::Property::Array *)jarg2;
17927   if (!arg2) {
17928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17929     return 0;
17930   }
17931   {
17932     try {
17933       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17934     } catch (std::out_of_range& e) {
17935       {
17936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17937       };
17938     } catch (std::exception& e) {
17939       {
17940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17941       };
17942     } catch (Dali::DaliException e) {
17943       {
17944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17945       };
17946     } catch (...) {
17947       {
17948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17949       };
17950     }
17951   }
17952
17953   jresult = result;
17954   return jresult;
17955 }
17956
17957
17958 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17959   unsigned int jresult ;
17960   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17961   Dali::Property::Map *arg2 = 0 ;
17962   bool result;
17963
17964   arg1 = (Dali::Property::Value *)jarg1;
17965   arg2 = (Dali::Property::Map *)jarg2;
17966   if (!arg2) {
17967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17968     return 0;
17969   }
17970   {
17971     try {
17972       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17973     } catch (std::out_of_range& e) {
17974       {
17975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17976       };
17977     } catch (std::exception& e) {
17978       {
17979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17980       };
17981     } catch (Dali::DaliException e) {
17982       {
17983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17984       };
17985     } catch (...) {
17986       {
17987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17988       };
17989     }
17990   }
17991
17992   jresult = result;
17993   return jresult;
17994 }
17995
17996
17997 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17998   unsigned int jresult ;
17999   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18000   Extents *arg2 = 0 ;
18001   bool result;
18002
18003   arg1 = (Dali::Property::Value *)jarg1;
18004   arg2 = (Extents *)jarg2;
18005   if (!arg2) {
18006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
18007     return 0;
18008   }
18009   {
18010     try {
18011       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
18012     } catch (std::out_of_range& e) {
18013       {
18014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18015       };
18016     } catch (std::exception& e) {
18017       {
18018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18019       };
18020     } catch (...) {
18021       {
18022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18023       };
18024     }
18025   }
18026   jresult = result;
18027   return jresult;
18028 }
18029
18030
18031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
18032   void * jresult ;
18033   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18034   Dali::Property::Array *result = 0 ;
18035
18036   arg1 = (Dali::Property::Value *)jarg1;
18037   {
18038     try {
18039       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
18040     } catch (std::out_of_range& e) {
18041       {
18042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18043       };
18044     } catch (std::exception& e) {
18045       {
18046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18047       };
18048     } catch (Dali::DaliException e) {
18049       {
18050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18051       };
18052     } catch (...) {
18053       {
18054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18055       };
18056     }
18057   }
18058
18059   jresult = (void *)result;
18060   return jresult;
18061 }
18062
18063
18064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
18065   void * jresult ;
18066   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18067   Dali::Property::Map *result = 0 ;
18068
18069   arg1 = (Dali::Property::Value *)jarg1;
18070   {
18071     try {
18072       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
18073     } catch (std::out_of_range& e) {
18074       {
18075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18076       };
18077     } catch (std::exception& e) {
18078       {
18079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18080       };
18081     } catch (Dali::DaliException e) {
18082       {
18083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18084       };
18085     } catch (...) {
18086       {
18087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18088       };
18089     }
18090   }
18091
18092   jresult = (void *)result;
18093   return jresult;
18094 }
18095
18096
18097 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18098   char * jresult ;
18099   Dali::Property::Type arg1 ;
18100   char *result = 0 ;
18101
18102   arg1 = (Dali::Property::Type)jarg1;
18103   {
18104     try {
18105       result = (char *)Dali::PropertyTypes::GetName(arg1);
18106     } catch (std::out_of_range& e) {
18107       {
18108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18109       };
18110     } catch (std::exception& e) {
18111       {
18112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18113       };
18114     } catch (Dali::DaliException e) {
18115       {
18116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18117       };
18118     } catch (...) {
18119       {
18120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18121       };
18122     }
18123   }
18124
18125   jresult = SWIG_csharp_string_callback((const char *)result);
18126   return jresult;
18127 }
18128
18129
18130 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18131   unsigned int jresult ;
18132   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18133   std::string *arg2 = 0 ;
18134   Dali::Property::Map *arg3 = 0 ;
18135   bool result;
18136
18137   arg1 = (Dali::BaseObject *)jarg1;
18138   if (!jarg2) {
18139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18140     return 0;
18141   }
18142   std::string arg2_str(jarg2);
18143   arg2 = &arg2_str;
18144   arg3 = (Dali::Property::Map *)jarg3;
18145   if (!arg3) {
18146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18147     return 0;
18148   }
18149   {
18150     try {
18151       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18152     } catch (std::out_of_range& e) {
18153       {
18154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18155       };
18156     } catch (std::exception& e) {
18157       {
18158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18159       };
18160     } catch (Dali::DaliException e) {
18161       {
18162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18163       };
18164     } catch (...) {
18165       {
18166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18167       };
18168     }
18169   }
18170
18171   jresult = result;
18172
18173   //argout typemap for const std::string&
18174
18175   return jresult;
18176 }
18177
18178
18179 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18180   char * jresult ;
18181   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18182   std::string *result = 0 ;
18183
18184   arg1 = (Dali::BaseObject *)jarg1;
18185   {
18186     try {
18187       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18188     } catch (std::out_of_range& e) {
18189       {
18190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18191       };
18192     } catch (std::exception& e) {
18193       {
18194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18195       };
18196     } catch (Dali::DaliException e) {
18197       {
18198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18199       };
18200     } catch (...) {
18201       {
18202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18203       };
18204     }
18205   }
18206
18207   jresult = SWIG_csharp_string_callback(result->c_str());
18208   return jresult;
18209 }
18210
18211
18212 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18213   unsigned int jresult ;
18214   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18215   Dali::TypeInfo *arg2 = 0 ;
18216   bool result;
18217
18218   arg1 = (Dali::BaseObject *)jarg1;
18219   arg2 = (Dali::TypeInfo *)jarg2;
18220   if (!arg2) {
18221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18222     return 0;
18223   }
18224   {
18225     try {
18226       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18227     } catch (std::out_of_range& e) {
18228       {
18229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18230       };
18231     } catch (std::exception& e) {
18232       {
18233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18234       };
18235     } catch (Dali::DaliException e) {
18236       {
18237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18238       };
18239     } catch (...) {
18240       {
18241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18242       };
18243     }
18244   }
18245
18246   jresult = result;
18247   return jresult;
18248 }
18249
18250
18251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18252   unsigned int jresult ;
18253   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18254   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18255   std::string *arg3 = 0 ;
18256   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18257   bool result;
18258
18259   arg1 = (Dali::BaseObject *)jarg1;
18260   arg2 = (ConnectionTrackerInterface *)jarg2;
18261   if (!jarg3) {
18262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18263     return 0;
18264   }
18265   std::string arg3_str(jarg3);
18266   arg3 = &arg3_str;
18267   arg4 = (FunctorDelegate *)jarg4;
18268   {
18269     try {
18270       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18271     } catch (std::out_of_range& e) {
18272       {
18273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18274       };
18275     } catch (std::exception& e) {
18276       {
18277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18278       };
18279     } catch (Dali::DaliException e) {
18280       {
18281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18282       };
18283     } catch (...) {
18284       {
18285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18286       };
18287     }
18288   }
18289
18290   jresult = result;
18291
18292   //argout typemap for const std::string&
18293
18294   return jresult;
18295 }
18296
18297
18298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18299   void * jresult ;
18300   Dali::BaseHandle *arg1 = 0 ;
18301   Dali::BaseObject *result = 0 ;
18302
18303   arg1 = (Dali::BaseHandle *)jarg1;
18304   if (!arg1) {
18305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18306     return 0;
18307   }
18308   {
18309     try {
18310       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18311     } catch (std::out_of_range& e) {
18312       {
18313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18314       };
18315     } catch (std::exception& e) {
18316       {
18317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18318       };
18319     } catch (Dali::DaliException e) {
18320       {
18321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18322       };
18323     } catch (...) {
18324       {
18325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18326       };
18327     }
18328   }
18329
18330   jresult = (void *)result;
18331   return jresult;
18332 }
18333
18334
18335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18336   void * jresult ;
18337   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18338   Dali::BaseHandle *result = 0 ;
18339
18340   arg1 = (Dali::BaseObject *)jarg1;
18341   {
18342     try {
18343       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18344     } catch (std::out_of_range& e) {
18345       {
18346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18347       };
18348     } catch (std::exception& e) {
18349       {
18350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18351       };
18352     } catch (Dali::DaliException e) {
18353       {
18354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18355       };
18356     } catch (...) {
18357       {
18358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18359       };
18360     }
18361   }
18362
18363   jresult = (void *)result;
18364   return jresult;
18365 }
18366
18367
18368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18369   void * jresult ;
18370   Dali::BaseHandle *result = 0 ;
18371
18372   {
18373     try {
18374       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18375     } catch (std::out_of_range& e) {
18376       {
18377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18378       };
18379     } catch (std::exception& e) {
18380       {
18381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18382       };
18383     } catch (Dali::DaliException e) {
18384       {
18385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18386       };
18387     } catch (...) {
18388       {
18389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18390       };
18391     }
18392   }
18393
18394   jresult = (void *)result;
18395   return jresult;
18396 }
18397
18398
18399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18400   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18401
18402   arg1 = (Dali::BaseHandle *)jarg1;
18403   {
18404     try {
18405       delete arg1;
18406     } catch (std::out_of_range& e) {
18407       {
18408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18409       };
18410     } catch (std::exception& e) {
18411       {
18412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18413       };
18414     } catch (Dali::DaliException e) {
18415       {
18416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18417       };
18418     } catch (...) {
18419       {
18420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18421       };
18422     }
18423   }
18424
18425 }
18426
18427
18428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18429   void * jresult ;
18430   Dali::BaseHandle *arg1 = 0 ;
18431   Dali::BaseHandle *result = 0 ;
18432
18433   arg1 = (Dali::BaseHandle *)jarg1;
18434   if (!arg1) {
18435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18436     return 0;
18437   }
18438   {
18439     try {
18440       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18441     } catch (std::out_of_range& e) {
18442       {
18443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18444       };
18445     } catch (std::exception& e) {
18446       {
18447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18448       };
18449     } catch (Dali::DaliException e) {
18450       {
18451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18452       };
18453     } catch (...) {
18454       {
18455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18456       };
18457     }
18458   }
18459
18460   jresult = (void *)result;
18461   return jresult;
18462 }
18463
18464
18465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18466   void * jresult ;
18467   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18468   Dali::BaseHandle *arg2 = 0 ;
18469   Dali::BaseHandle *result = 0 ;
18470
18471   arg1 = (Dali::BaseHandle *)jarg1;
18472   arg2 = (Dali::BaseHandle *)jarg2;
18473   if (!arg2) {
18474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18475     return 0;
18476   }
18477   {
18478     try {
18479       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18480     } catch (std::out_of_range& e) {
18481       {
18482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18483       };
18484     } catch (std::exception& e) {
18485       {
18486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18487       };
18488     } catch (Dali::DaliException e) {
18489       {
18490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18491       };
18492     } catch (...) {
18493       {
18494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18495       };
18496     }
18497   }
18498
18499   jresult = (void *)result;
18500   return jresult;
18501 }
18502
18503
18504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18505   unsigned int jresult ;
18506   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18507   std::string *arg2 = 0 ;
18508   Dali::Property::Map *arg3 = 0 ;
18509   bool result;
18510
18511   arg1 = (Dali::BaseHandle *)jarg1;
18512   if (!jarg2) {
18513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18514     return 0;
18515   }
18516   std::string arg2_str(jarg2);
18517   arg2 = &arg2_str;
18518   arg3 = (Dali::Property::Map *)jarg3;
18519   if (!arg3) {
18520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18521     return 0;
18522   }
18523   {
18524     try {
18525       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18526     } catch (std::out_of_range& e) {
18527       {
18528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18529       };
18530     } catch (std::exception& e) {
18531       {
18532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18533       };
18534     } catch (Dali::DaliException e) {
18535       {
18536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18537       };
18538     } catch (...) {
18539       {
18540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18541       };
18542     }
18543   }
18544
18545   jresult = result;
18546
18547   //argout typemap for const std::string&
18548
18549   return jresult;
18550 }
18551
18552
18553 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18554   char * jresult ;
18555   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18556   std::string *result = 0 ;
18557
18558   arg1 = (Dali::BaseHandle *)jarg1;
18559   {
18560     try {
18561       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18562     } catch (std::out_of_range& e) {
18563       {
18564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18565       };
18566     } catch (std::exception& e) {
18567       {
18568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18569       };
18570     } catch (Dali::DaliException e) {
18571       {
18572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18573       };
18574     } catch (...) {
18575       {
18576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18577       };
18578     }
18579   }
18580
18581   jresult = SWIG_csharp_string_callback(result->c_str());
18582   return jresult;
18583 }
18584
18585
18586 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18587   unsigned int jresult ;
18588   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18589   Dali::TypeInfo *arg2 = 0 ;
18590   bool result;
18591
18592   arg1 = (Dali::BaseHandle *)jarg1;
18593   arg2 = (Dali::TypeInfo *)jarg2;
18594   if (!arg2) {
18595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18596     return 0;
18597   }
18598   {
18599     try {
18600       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18601     } catch (std::out_of_range& e) {
18602       {
18603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18604       };
18605     } catch (std::exception& e) {
18606       {
18607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18608       };
18609     } catch (Dali::DaliException e) {
18610       {
18611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18612       };
18613     } catch (...) {
18614       {
18615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18616       };
18617     }
18618   }
18619
18620   jresult = result;
18621   return jresult;
18622 }
18623
18624
18625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18626   void * jresult ;
18627   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18628   Dali::BaseObject *result = 0 ;
18629
18630   arg1 = (Dali::BaseHandle *)jarg1;
18631   {
18632     try {
18633       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18634     } catch (std::out_of_range& e) {
18635       {
18636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18637       };
18638     } catch (std::exception& e) {
18639       {
18640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18641       };
18642     } catch (Dali::DaliException e) {
18643       {
18644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18645       };
18646     } catch (...) {
18647       {
18648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18649       };
18650     }
18651   }
18652
18653   jresult = (void *)result;
18654   return jresult;
18655 }
18656
18657
18658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18659   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18660
18661   arg1 = (Dali::BaseHandle *)jarg1;
18662   {
18663     try {
18664       (arg1)->Reset();
18665     } catch (std::out_of_range& e) {
18666       {
18667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18668       };
18669     } catch (std::exception& e) {
18670       {
18671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18672       };
18673     } catch (Dali::DaliException e) {
18674       {
18675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18676       };
18677     } catch (...) {
18678       {
18679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18680       };
18681     }
18682   }
18683
18684 }
18685
18686
18687 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18688   unsigned int jresult ;
18689   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18690   Dali::BaseHandle *arg2 = 0 ;
18691   bool result;
18692
18693   arg1 = (Dali::BaseHandle *)jarg1;
18694   arg2 = (Dali::BaseHandle *)jarg2;
18695   if (!arg2) {
18696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18697     return 0;
18698   }
18699   {
18700     try {
18701       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18702     } catch (std::out_of_range& e) {
18703       {
18704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18705       };
18706     } catch (std::exception& e) {
18707       {
18708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18709       };
18710     } catch (Dali::DaliException e) {
18711       {
18712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18713       };
18714     } catch (...) {
18715       {
18716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18717       };
18718     }
18719   }
18720
18721   jresult = result;
18722   return jresult;
18723 }
18724
18725
18726 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18727   unsigned int jresult ;
18728   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18729   Dali::BaseHandle *arg2 = 0 ;
18730   bool result;
18731
18732   arg1 = (Dali::BaseHandle *)jarg1;
18733   arg2 = (Dali::BaseHandle *)jarg2;
18734   if (!arg2) {
18735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18736     return 0;
18737   }
18738   {
18739     try {
18740       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18741     } catch (std::out_of_range& e) {
18742       {
18743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18744       };
18745     } catch (std::exception& e) {
18746       {
18747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18748       };
18749     } catch (Dali::DaliException e) {
18750       {
18751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18752       };
18753     } catch (...) {
18754       {
18755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18756       };
18757     }
18758   }
18759
18760   jresult = result;
18761   return jresult;
18762 }
18763
18764
18765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18766   void * jresult ;
18767   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18768   Dali::RefObject *result = 0 ;
18769
18770   arg1 = (Dali::BaseHandle *)jarg1;
18771   {
18772     try {
18773       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18774     } catch (std::out_of_range& e) {
18775       {
18776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18777       };
18778     } catch (std::exception& e) {
18779       {
18780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18781       };
18782     } catch (Dali::DaliException e) {
18783       {
18784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18785       };
18786     } catch (...) {
18787       {
18788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18789       };
18790     }
18791   }
18792
18793   jresult = (void *)result;
18794   return jresult;
18795 }
18796
18797
18798 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18799   unsigned int jresult ;
18800   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18801   bool result;
18802
18803   arg1 = (Dali::BaseHandle *)jarg1;
18804   {
18805     try {
18806       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18807     } catch (std::out_of_range& e) {
18808       {
18809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18810       };
18811     } catch (std::exception& e) {
18812       {
18813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18814       };
18815     } catch (Dali::DaliException e) {
18816       {
18817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18818       };
18819     } catch (...) {
18820       {
18821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18822       };
18823     }
18824   }
18825
18826   jresult = result;
18827   return jresult;
18828 }
18829
18830
18831 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18832   unsigned int jresult ;
18833   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18834   Dali::BaseHandle *arg2 = 0 ;
18835   bool result;
18836
18837   arg1 = (Dali::BaseHandle *)jarg1;
18838   arg2 = (Dali::BaseHandle *)jarg2;
18839   if (!arg2) {
18840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18841     return 0;
18842   }
18843   {
18844     try {
18845       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18846     } catch (std::out_of_range& e) {
18847       {
18848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18849       };
18850     } catch (std::exception& e) {
18851       {
18852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18853       };
18854     } catch (Dali::DaliException e) {
18855       {
18856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18857       };
18858     } catch (...) {
18859       {
18860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18861       };
18862     }
18863   }
18864
18865   jresult = result;
18866   return jresult;
18867 }
18868
18869
18870 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18871   unsigned int jresult ;
18872   Dali::BaseHandle *arg1 = 0 ;
18873   Dali::BaseHandle *arg2 = 0 ;
18874   bool result;
18875
18876   arg1 = (Dali::BaseHandle *)jarg1;
18877   if (!arg1) {
18878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18879     return 0;
18880   }
18881   arg2 = (Dali::BaseHandle *)jarg2;
18882   if (!arg2) {
18883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18884     return 0;
18885   }
18886   {
18887     try {
18888       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18889     } catch (std::out_of_range& e) {
18890       {
18891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18892       };
18893     } catch (std::exception& e) {
18894       {
18895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18896       };
18897     } catch (Dali::DaliException e) {
18898       {
18899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18900       };
18901     } catch (...) {
18902       {
18903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18904       };
18905     }
18906   }
18907
18908   jresult = result;
18909   return jresult;
18910 }
18911
18912
18913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18914   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18915
18916   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18917   {
18918     try {
18919       delete arg1;
18920     } catch (std::out_of_range& e) {
18921       {
18922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18923       };
18924     } catch (std::exception& e) {
18925       {
18926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18927       };
18928     } catch (Dali::DaliException e) {
18929       {
18930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18931       };
18932     } catch (...) {
18933       {
18934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18935       };
18936     }
18937   }
18938
18939 }
18940
18941
18942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18943   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18944   SlotObserver *arg2 = (SlotObserver *) 0 ;
18945   CallbackBase *arg3 = (CallbackBase *) 0 ;
18946
18947   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18948   arg2 = (SlotObserver *)jarg2;
18949   arg3 = (CallbackBase *)jarg3;
18950   {
18951     try {
18952       (arg1)->SignalConnected(arg2,arg3);
18953     } catch (std::out_of_range& e) {
18954       {
18955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18956       };
18957     } catch (std::exception& e) {
18958       {
18959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18960       };
18961     } catch (Dali::DaliException e) {
18962       {
18963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18964       };
18965     } catch (...) {
18966       {
18967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18968       };
18969     }
18970   }
18971
18972 }
18973
18974
18975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18976   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18977
18978   arg1 = (Dali::SignalObserver *)jarg1;
18979   {
18980     try {
18981       delete arg1;
18982     } catch (std::out_of_range& e) {
18983       {
18984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18985       };
18986     } catch (std::exception& e) {
18987       {
18988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18989       };
18990     } catch (Dali::DaliException e) {
18991       {
18992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18993       };
18994     } catch (...) {
18995       {
18996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18997       };
18998     }
18999   }
19000
19001 }
19002
19003
19004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19005   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
19006   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19007   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19008
19009   arg1 = (Dali::SignalObserver *)jarg1;
19010   arg2 = (Dali::SlotObserver *)jarg2;
19011   arg3 = (Dali::CallbackBase *)jarg3;
19012   {
19013     try {
19014       (arg1)->SignalDisconnected(arg2,arg3);
19015     } catch (std::out_of_range& e) {
19016       {
19017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19018       };
19019     } catch (std::exception& e) {
19020       {
19021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19022       };
19023     } catch (Dali::DaliException e) {
19024       {
19025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19026       };
19027     } catch (...) {
19028       {
19029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19030       };
19031     }
19032   }
19033
19034 }
19035
19036
19037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
19038   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19039
19040   arg1 = (Dali::SlotObserver *)jarg1;
19041   {
19042     try {
19043       delete arg1;
19044     } catch (std::out_of_range& e) {
19045       {
19046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19047       };
19048     } catch (std::exception& e) {
19049       {
19050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19051       };
19052     } catch (Dali::DaliException e) {
19053       {
19054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19055       };
19056     } catch (...) {
19057       {
19058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19059       };
19060     }
19061   }
19062
19063 }
19064
19065
19066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
19067   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19068   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
19069
19070   arg1 = (Dali::SlotObserver *)jarg1;
19071   arg2 = (Dali::CallbackBase *)jarg2;
19072   {
19073     try {
19074       (arg1)->SlotDisconnected(arg2);
19075     } catch (std::out_of_range& e) {
19076       {
19077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19078       };
19079     } catch (std::exception& e) {
19080       {
19081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19082       };
19083     } catch (Dali::DaliException e) {
19084       {
19085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19086       };
19087     } catch (...) {
19088       {
19089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19090       };
19091     }
19092   }
19093
19094 }
19095
19096
19097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19098   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19099
19100   arg1 = (Dali::ConnectionTracker *)jarg1;
19101   {
19102     try {
19103       delete arg1;
19104     } catch (std::out_of_range& e) {
19105       {
19106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19107       };
19108     } catch (std::exception& e) {
19109       {
19110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19111       };
19112     } catch (Dali::DaliException e) {
19113       {
19114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19115       };
19116     } catch (...) {
19117       {
19118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19119       };
19120     }
19121   }
19122
19123 }
19124
19125
19126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19127   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19128
19129   arg1 = (Dali::ConnectionTracker *)jarg1;
19130   {
19131     try {
19132       (arg1)->DisconnectAll();
19133     } catch (std::out_of_range& e) {
19134       {
19135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19136       };
19137     } catch (std::exception& e) {
19138       {
19139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19140       };
19141     } catch (Dali::DaliException e) {
19142       {
19143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19144       };
19145     } catch (...) {
19146       {
19147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19148       };
19149     }
19150   }
19151
19152 }
19153
19154
19155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19156   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19157   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19158   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19159
19160   arg1 = (Dali::ConnectionTracker *)jarg1;
19161   arg2 = (Dali::SlotObserver *)jarg2;
19162   arg3 = (Dali::CallbackBase *)jarg3;
19163   {
19164     try {
19165       (arg1)->SignalConnected(arg2,arg3);
19166     } catch (std::out_of_range& e) {
19167       {
19168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19169       };
19170     } catch (std::exception& e) {
19171       {
19172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19173       };
19174     } catch (Dali::DaliException e) {
19175       {
19176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19177       };
19178     } catch (...) {
19179       {
19180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19181       };
19182     }
19183   }
19184
19185 }
19186
19187
19188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19189   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19190   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19191   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19192
19193   arg1 = (Dali::ConnectionTracker *)jarg1;
19194   arg2 = (Dali::SlotObserver *)jarg2;
19195   arg3 = (Dali::CallbackBase *)jarg3;
19196   {
19197     try {
19198       (arg1)->SignalDisconnected(arg2,arg3);
19199     } catch (std::out_of_range& e) {
19200       {
19201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19202       };
19203     } catch (std::exception& e) {
19204       {
19205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19206       };
19207     } catch (Dali::DaliException e) {
19208       {
19209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19210       };
19211     } catch (...) {
19212       {
19213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19214       };
19215     }
19216   }
19217
19218 }
19219
19220
19221 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19222   unsigned long jresult ;
19223   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19224   std::size_t result;
19225
19226   arg1 = (Dali::ConnectionTracker *)jarg1;
19227   {
19228     try {
19229       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19230     } catch (std::out_of_range& e) {
19231       {
19232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19233       };
19234     } catch (std::exception& e) {
19235       {
19236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19237       };
19238     } catch (Dali::DaliException e) {
19239       {
19240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19241       };
19242     } catch (...) {
19243       {
19244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19245       };
19246     }
19247   }
19248
19249   jresult = (unsigned long)result;
19250   return jresult;
19251 }
19252
19253
19254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19255   void * jresult ;
19256   Dali::ObjectRegistry *result = 0 ;
19257
19258   {
19259     try {
19260       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19261     } catch (std::out_of_range& e) {
19262       {
19263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19264       };
19265     } catch (std::exception& e) {
19266       {
19267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19268       };
19269     } catch (Dali::DaliException e) {
19270       {
19271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19272       };
19273     } catch (...) {
19274       {
19275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19276       };
19277     }
19278   }
19279
19280   jresult = (void *)result;
19281   return jresult;
19282 }
19283
19284
19285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19286   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19287
19288   arg1 = (Dali::ObjectRegistry *)jarg1;
19289   {
19290     try {
19291       delete arg1;
19292     } catch (std::out_of_range& e) {
19293       {
19294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19295       };
19296     } catch (std::exception& e) {
19297       {
19298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19299       };
19300     } catch (Dali::DaliException e) {
19301       {
19302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19303       };
19304     } catch (...) {
19305       {
19306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19307       };
19308     }
19309   }
19310
19311 }
19312
19313
19314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19315   void * jresult ;
19316   Dali::ObjectRegistry *arg1 = 0 ;
19317   Dali::ObjectRegistry *result = 0 ;
19318
19319   arg1 = (Dali::ObjectRegistry *)jarg1;
19320   if (!arg1) {
19321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19322     return 0;
19323   }
19324   {
19325     try {
19326       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19327     } catch (std::out_of_range& e) {
19328       {
19329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19330       };
19331     } catch (std::exception& e) {
19332       {
19333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19334       };
19335     } catch (Dali::DaliException e) {
19336       {
19337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19338       };
19339     } catch (...) {
19340       {
19341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19342       };
19343     }
19344   }
19345
19346   jresult = (void *)result;
19347   return jresult;
19348 }
19349
19350
19351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19352   void * jresult ;
19353   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19354   Dali::ObjectRegistry *arg2 = 0 ;
19355   Dali::ObjectRegistry *result = 0 ;
19356
19357   arg1 = (Dali::ObjectRegistry *)jarg1;
19358   arg2 = (Dali::ObjectRegistry *)jarg2;
19359   if (!arg2) {
19360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19361     return 0;
19362   }
19363   {
19364     try {
19365       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19366     } catch (std::out_of_range& e) {
19367       {
19368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19369       };
19370     } catch (std::exception& e) {
19371       {
19372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19373       };
19374     } catch (Dali::DaliException e) {
19375       {
19376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19377       };
19378     } catch (...) {
19379       {
19380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19381       };
19382     }
19383   }
19384
19385   jresult = (void *)result;
19386   return jresult;
19387 }
19388
19389
19390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19391   void * jresult ;
19392   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19393   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19394
19395   arg1 = (Dali::ObjectRegistry *)jarg1;
19396   {
19397     try {
19398       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19399     } catch (std::out_of_range& e) {
19400       {
19401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19402       };
19403     } catch (std::exception& e) {
19404       {
19405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19406       };
19407     } catch (Dali::DaliException e) {
19408       {
19409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19410       };
19411     } catch (...) {
19412       {
19413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19414       };
19415     }
19416   }
19417
19418   jresult = (void *)result;
19419   return jresult;
19420 }
19421
19422
19423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19424   void * jresult ;
19425   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19426   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19427
19428   arg1 = (Dali::ObjectRegistry *)jarg1;
19429   {
19430     try {
19431       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19432     } catch (std::out_of_range& e) {
19433       {
19434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19435       };
19436     } catch (std::exception& e) {
19437       {
19438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19439       };
19440     } catch (Dali::DaliException e) {
19441       {
19442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19443       };
19444     } catch (...) {
19445       {
19446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19447       };
19448     }
19449   }
19450
19451   jresult = (void *)result;
19452   return jresult;
19453 }
19454
19455
19456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19457   void * jresult ;
19458   Dali::PropertyCondition *result = 0 ;
19459
19460   {
19461     try {
19462       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19463     } catch (std::out_of_range& e) {
19464       {
19465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19466       };
19467     } catch (std::exception& e) {
19468       {
19469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19470       };
19471     } catch (Dali::DaliException e) {
19472       {
19473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19474       };
19475     } catch (...) {
19476       {
19477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19478       };
19479     }
19480   }
19481
19482   jresult = (void *)result;
19483   return jresult;
19484 }
19485
19486
19487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19488   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19489
19490   arg1 = (Dali::PropertyCondition *)jarg1;
19491   {
19492     try {
19493       delete arg1;
19494     } catch (std::out_of_range& e) {
19495       {
19496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19497       };
19498     } catch (std::exception& e) {
19499       {
19500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19501       };
19502     } catch (Dali::DaliException e) {
19503       {
19504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19505       };
19506     } catch (...) {
19507       {
19508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19509       };
19510     }
19511   }
19512
19513 }
19514
19515
19516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19517   void * jresult ;
19518   Dali::PropertyCondition *arg1 = 0 ;
19519   Dali::PropertyCondition *result = 0 ;
19520
19521   arg1 = (Dali::PropertyCondition *)jarg1;
19522   if (!arg1) {
19523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19524     return 0;
19525   }
19526   {
19527     try {
19528       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19529     } catch (std::out_of_range& e) {
19530       {
19531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19532       };
19533     } catch (std::exception& e) {
19534       {
19535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19536       };
19537     } catch (Dali::DaliException e) {
19538       {
19539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19540       };
19541     } catch (...) {
19542       {
19543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19544       };
19545     }
19546   }
19547
19548   jresult = (void *)result;
19549   return jresult;
19550 }
19551
19552
19553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19554   void * jresult ;
19555   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19556   Dali::PropertyCondition *arg2 = 0 ;
19557   Dali::PropertyCondition *result = 0 ;
19558
19559   arg1 = (Dali::PropertyCondition *)jarg1;
19560   arg2 = (Dali::PropertyCondition *)jarg2;
19561   if (!arg2) {
19562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19563     return 0;
19564   }
19565   {
19566     try {
19567       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19568     } catch (std::out_of_range& e) {
19569       {
19570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19571       };
19572     } catch (std::exception& e) {
19573       {
19574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19575       };
19576     } catch (Dali::DaliException e) {
19577       {
19578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19579       };
19580     } catch (...) {
19581       {
19582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19583       };
19584     }
19585   }
19586
19587   jresult = (void *)result;
19588   return jresult;
19589 }
19590
19591
19592 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19593   unsigned long jresult ;
19594   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19595   std::size_t result;
19596
19597   arg1 = (Dali::PropertyCondition *)jarg1;
19598   {
19599     try {
19600       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19601     } catch (std::out_of_range& e) {
19602       {
19603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19604       };
19605     } catch (std::exception& e) {
19606       {
19607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19608       };
19609     } catch (...) {
19610       {
19611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19612       };
19613     }
19614   }
19615   jresult = (unsigned long)result;
19616   return jresult;
19617 }
19618
19619
19620 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19621   float jresult ;
19622   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19623   std::size_t arg2 ;
19624   float result;
19625
19626   arg1 = (Dali::PropertyCondition *)jarg1;
19627   arg2 = (std::size_t)jarg2;
19628   {
19629     try {
19630       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19631     } catch (std::out_of_range& e) {
19632       {
19633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19634       };
19635     } catch (std::exception& e) {
19636       {
19637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19638       };
19639     } catch (...) {
19640       {
19641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19642       };
19643     }
19644   }
19645   jresult = result;
19646   return jresult;
19647 }
19648
19649
19650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19651   void * jresult ;
19652   float arg1 ;
19653   Dali::PropertyCondition result;
19654
19655   arg1 = (float)jarg1;
19656   {
19657     try {
19658       result = Dali::LessThanCondition(arg1);
19659     } catch (std::out_of_range& e) {
19660       {
19661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19662       };
19663     } catch (std::exception& e) {
19664       {
19665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19666       };
19667     } catch (Dali::DaliException e) {
19668       {
19669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19670       };
19671     } catch (...) {
19672       {
19673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19674       };
19675     }
19676   }
19677
19678   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19679   return jresult;
19680 }
19681
19682
19683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19684   void * jresult ;
19685   float arg1 ;
19686   Dali::PropertyCondition result;
19687
19688   arg1 = (float)jarg1;
19689   {
19690     try {
19691       result = Dali::GreaterThanCondition(arg1);
19692     } catch (std::out_of_range& e) {
19693       {
19694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19695       };
19696     } catch (std::exception& e) {
19697       {
19698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19699       };
19700     } catch (Dali::DaliException e) {
19701       {
19702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19703       };
19704     } catch (...) {
19705       {
19706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19707       };
19708     }
19709   }
19710
19711   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19712   return jresult;
19713 }
19714
19715
19716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19717   void * jresult ;
19718   float arg1 ;
19719   float arg2 ;
19720   Dali::PropertyCondition result;
19721
19722   arg1 = (float)jarg1;
19723   arg2 = (float)jarg2;
19724   {
19725     try {
19726       result = Dali::InsideCondition(arg1,arg2);
19727     } catch (std::out_of_range& e) {
19728       {
19729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19730       };
19731     } catch (std::exception& e) {
19732       {
19733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19734       };
19735     } catch (Dali::DaliException e) {
19736       {
19737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19738       };
19739     } catch (...) {
19740       {
19741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19742       };
19743     }
19744   }
19745
19746   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19747   return jresult;
19748 }
19749
19750
19751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19752   void * jresult ;
19753   float arg1 ;
19754   float arg2 ;
19755   Dali::PropertyCondition result;
19756
19757   arg1 = (float)jarg1;
19758   arg2 = (float)jarg2;
19759   {
19760     try {
19761       result = Dali::OutsideCondition(arg1,arg2);
19762     } catch (std::out_of_range& e) {
19763       {
19764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19765       };
19766     } catch (std::exception& e) {
19767       {
19768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19769       };
19770     } catch (Dali::DaliException e) {
19771       {
19772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19773       };
19774     } catch (...) {
19775       {
19776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19777       };
19778     }
19779   }
19780
19781   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19782   return jresult;
19783 }
19784
19785
19786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19787   void * jresult ;
19788   float arg1 ;
19789   float arg2 ;
19790   Dali::PropertyCondition result;
19791
19792   arg1 = (float)jarg1;
19793   arg2 = (float)jarg2;
19794   {
19795     try {
19796       result = Dali::StepCondition(arg1,arg2);
19797     } catch (std::out_of_range& e) {
19798       {
19799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19800       };
19801     } catch (std::exception& e) {
19802       {
19803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19804       };
19805     } catch (Dali::DaliException e) {
19806       {
19807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19808       };
19809     } catch (...) {
19810       {
19811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19812       };
19813     }
19814   }
19815
19816   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19817   return jresult;
19818 }
19819
19820
19821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19822   void * jresult ;
19823   float arg1 ;
19824   Dali::PropertyCondition result;
19825
19826   arg1 = (float)jarg1;
19827   {
19828     try {
19829       result = Dali::StepCondition(arg1);
19830     } catch (std::out_of_range& e) {
19831       {
19832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19833       };
19834     } catch (std::exception& e) {
19835       {
19836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19837       };
19838     } catch (Dali::DaliException e) {
19839       {
19840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19841       };
19842     } catch (...) {
19843       {
19844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19845       };
19846     }
19847   }
19848
19849   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19850   return jresult;
19851 }
19852
19853
19854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19855   void * jresult ;
19856   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19857   Dali::PropertyCondition result;
19858
19859   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19860   if (!arg1) {
19861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19862     return 0;
19863   }
19864   {
19865     try {
19866       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19867     } catch (std::out_of_range& e) {
19868       {
19869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19870       };
19871     } catch (std::exception& e) {
19872       {
19873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19874       };
19875     } catch (Dali::DaliException e) {
19876       {
19877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19878       };
19879     } catch (...) {
19880       {
19881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19882       };
19883     }
19884   }
19885
19886   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19887   return jresult;
19888 }
19889
19890
19891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19892   void * jresult ;
19893   Dali::PropertyNotification *result = 0 ;
19894
19895   {
19896     try {
19897       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19898     } catch (std::out_of_range& e) {
19899       {
19900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19901       };
19902     } catch (std::exception& e) {
19903       {
19904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19905       };
19906     } catch (Dali::DaliException e) {
19907       {
19908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19909       };
19910     } catch (...) {
19911       {
19912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19913       };
19914     }
19915   }
19916
19917   jresult = (void *)result;
19918   return jresult;
19919 }
19920
19921
19922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19923   void * jresult ;
19924   Dali::BaseHandle arg1 ;
19925   Dali::BaseHandle *argp1 ;
19926   Dali::PropertyNotification result;
19927
19928   argp1 = (Dali::BaseHandle *)jarg1;
19929   if (!argp1) {
19930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19931     return 0;
19932   }
19933   arg1 = *argp1;
19934   {
19935     try {
19936       result = Dali::PropertyNotification::DownCast(arg1);
19937     } catch (std::out_of_range& e) {
19938       {
19939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19940       };
19941     } catch (std::exception& e) {
19942       {
19943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19944       };
19945     } catch (Dali::DaliException e) {
19946       {
19947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19948       };
19949     } catch (...) {
19950       {
19951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19952       };
19953     }
19954   }
19955
19956   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19957   return jresult;
19958 }
19959
19960
19961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19962   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19963
19964   arg1 = (Dali::PropertyNotification *)jarg1;
19965   {
19966     try {
19967       delete arg1;
19968     } catch (std::out_of_range& e) {
19969       {
19970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19971       };
19972     } catch (std::exception& e) {
19973       {
19974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19975       };
19976     } catch (Dali::DaliException e) {
19977       {
19978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19979       };
19980     } catch (...) {
19981       {
19982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19983       };
19984     }
19985   }
19986
19987 }
19988
19989
19990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19991   void * jresult ;
19992   Dali::PropertyNotification *arg1 = 0 ;
19993   Dali::PropertyNotification *result = 0 ;
19994
19995   arg1 = (Dali::PropertyNotification *)jarg1;
19996   if (!arg1) {
19997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19998     return 0;
19999   }
20000   {
20001     try {
20002       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
20003     } catch (std::out_of_range& e) {
20004       {
20005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20006       };
20007     } catch (std::exception& e) {
20008       {
20009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20010       };
20011     } catch (Dali::DaliException e) {
20012       {
20013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20014       };
20015     } catch (...) {
20016       {
20017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20018       };
20019     }
20020   }
20021
20022   jresult = (void *)result;
20023   return jresult;
20024 }
20025
20026
20027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
20028   void * jresult ;
20029   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20030   Dali::PropertyNotification *arg2 = 0 ;
20031   Dali::PropertyNotification *result = 0 ;
20032
20033   arg1 = (Dali::PropertyNotification *)jarg1;
20034   arg2 = (Dali::PropertyNotification *)jarg2;
20035   if (!arg2) {
20036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
20037     return 0;
20038   }
20039   {
20040     try {
20041       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
20042     } catch (std::out_of_range& e) {
20043       {
20044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20045       };
20046     } catch (std::exception& e) {
20047       {
20048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20049       };
20050     } catch (Dali::DaliException e) {
20051       {
20052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20053       };
20054     } catch (...) {
20055       {
20056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20057       };
20058     }
20059   }
20060
20061   jresult = (void *)result;
20062   return jresult;
20063 }
20064
20065
20066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
20067   void * jresult ;
20068   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20069   Dali::PropertyCondition result;
20070
20071   arg1 = (Dali::PropertyNotification *)jarg1;
20072   {
20073     try {
20074       result = (arg1)->GetCondition();
20075     } catch (std::out_of_range& e) {
20076       {
20077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20078       };
20079     } catch (std::exception& e) {
20080       {
20081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20082       };
20083     } catch (Dali::DaliException e) {
20084       {
20085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20086       };
20087     } catch (...) {
20088       {
20089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20090       };
20091     }
20092   }
20093
20094   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20095   return jresult;
20096 }
20097
20098
20099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20100   void * jresult ;
20101   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20102   Dali::Handle result;
20103
20104   arg1 = (Dali::PropertyNotification *)jarg1;
20105   {
20106     try {
20107       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20108     } catch (std::out_of_range& e) {
20109       {
20110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20111       };
20112     } catch (std::exception& e) {
20113       {
20114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20115       };
20116     } catch (Dali::DaliException e) {
20117       {
20118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20119       };
20120     } catch (...) {
20121       {
20122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20123       };
20124     }
20125   }
20126
20127   jresult = new Dali::Handle((const Dali::Handle &)result);
20128   return jresult;
20129 }
20130
20131
20132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20133   int jresult ;
20134   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20135   Dali::Property::Index result;
20136
20137   arg1 = (Dali::PropertyNotification *)jarg1;
20138   {
20139     try {
20140       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20141     } catch (std::out_of_range& e) {
20142       {
20143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20144       };
20145     } catch (std::exception& e) {
20146       {
20147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20148       };
20149     } catch (Dali::DaliException e) {
20150       {
20151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20152       };
20153     } catch (...) {
20154       {
20155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20156       };
20157     }
20158   }
20159
20160   jresult = result;
20161   return jresult;
20162 }
20163
20164
20165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20166   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20167   Dali::PropertyNotification::NotifyMode arg2 ;
20168
20169   arg1 = (Dali::PropertyNotification *)jarg1;
20170   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20171   {
20172     try {
20173       (arg1)->SetNotifyMode(arg2);
20174     } catch (std::out_of_range& e) {
20175       {
20176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20177       };
20178     } catch (std::exception& e) {
20179       {
20180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20181       };
20182     } catch (Dali::DaliException e) {
20183       {
20184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20185       };
20186     } catch (...) {
20187       {
20188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20189       };
20190     }
20191   }
20192
20193 }
20194
20195
20196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20197   int jresult ;
20198   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20199   Dali::PropertyNotification::NotifyMode result;
20200
20201   arg1 = (Dali::PropertyNotification *)jarg1;
20202   {
20203     try {
20204       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20205     } catch (std::out_of_range& e) {
20206       {
20207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20208       };
20209     } catch (std::exception& e) {
20210       {
20211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20212       };
20213     } catch (Dali::DaliException e) {
20214       {
20215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20216       };
20217     } catch (...) {
20218       {
20219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20220       };
20221     }
20222   }
20223
20224   jresult = (int)result;
20225   return jresult;
20226 }
20227
20228
20229 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20230   unsigned int jresult ;
20231   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20232   bool result;
20233
20234   arg1 = (Dali::PropertyNotification *)jarg1;
20235   {
20236     try {
20237       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20238     } catch (std::out_of_range& e) {
20239       {
20240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20241       };
20242     } catch (std::exception& e) {
20243       {
20244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20245       };
20246     } catch (Dali::DaliException e) {
20247       {
20248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20249       };
20250     } catch (...) {
20251       {
20252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20253       };
20254     }
20255   }
20256
20257   jresult = result;
20258   return jresult;
20259 }
20260
20261
20262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20263   void * jresult ;
20264   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20265   Dali::PropertyNotifySignalType *result = 0 ;
20266
20267   arg1 = (Dali::PropertyNotification *)jarg1;
20268   {
20269     try {
20270       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20271     } catch (std::out_of_range& e) {
20272       {
20273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20274       };
20275     } catch (std::exception& e) {
20276       {
20277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20278       };
20279     } catch (Dali::DaliException e) {
20280       {
20281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20282       };
20283     } catch (...) {
20284       {
20285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20286       };
20287     }
20288   }
20289
20290   jresult = (void *)result;
20291   return jresult;
20292 }
20293
20294
20295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20296   void * jresult ;
20297   Dali::Handle *result = 0 ;
20298
20299   {
20300     try {
20301       result = (Dali::Handle *)new Dali::Handle();
20302     } catch (std::out_of_range& e) {
20303       {
20304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20305       };
20306     } catch (std::exception& e) {
20307       {
20308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20309       };
20310     } catch (Dali::DaliException e) {
20311       {
20312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20313       };
20314     } catch (...) {
20315       {
20316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20317       };
20318     }
20319   }
20320
20321   jresult = (void *)result;
20322   return jresult;
20323 }
20324
20325
20326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20327   void * jresult ;
20328   Dali::Handle result;
20329
20330   {
20331     try {
20332       result = Dali::Handle::New();
20333     } catch (std::out_of_range& e) {
20334       {
20335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20336       };
20337     } catch (std::exception& e) {
20338       {
20339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20340       };
20341     } catch (Dali::DaliException e) {
20342       {
20343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20344       };
20345     } catch (...) {
20346       {
20347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20348       };
20349     }
20350   }
20351
20352   jresult = new Dali::Handle((const Dali::Handle &)result);
20353   return jresult;
20354 }
20355
20356
20357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20358   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20359
20360   arg1 = (Dali::Handle *)jarg1;
20361   {
20362     try {
20363       delete arg1;
20364     } catch (std::out_of_range& e) {
20365       {
20366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20367       };
20368     } catch (std::exception& e) {
20369       {
20370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20371       };
20372     } catch (Dali::DaliException e) {
20373       {
20374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20375       };
20376     } catch (...) {
20377       {
20378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20379       };
20380     }
20381   }
20382
20383 }
20384
20385
20386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20387   void * jresult ;
20388   Dali::Handle *arg1 = 0 ;
20389   Dali::Handle *result = 0 ;
20390
20391   arg1 = (Dali::Handle *)jarg1;
20392   if (!arg1) {
20393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20394     return 0;
20395   }
20396   {
20397     try {
20398       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20399     } catch (std::out_of_range& e) {
20400       {
20401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20402       };
20403     } catch (std::exception& e) {
20404       {
20405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20406       };
20407     } catch (Dali::DaliException e) {
20408       {
20409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20410       };
20411     } catch (...) {
20412       {
20413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20414       };
20415     }
20416   }
20417
20418   jresult = (void *)result;
20419   return jresult;
20420 }
20421
20422
20423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20424   void * jresult ;
20425   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20426   Dali::Handle *arg2 = 0 ;
20427   Dali::Handle *result = 0 ;
20428
20429   arg1 = (Dali::Handle *)jarg1;
20430   arg2 = (Dali::Handle *)jarg2;
20431   if (!arg2) {
20432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20433     return 0;
20434   }
20435   {
20436     try {
20437       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20438     } catch (std::out_of_range& e) {
20439       {
20440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20441       };
20442     } catch (std::exception& e) {
20443       {
20444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20445       };
20446     } catch (Dali::DaliException e) {
20447       {
20448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20449       };
20450     } catch (...) {
20451       {
20452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20453       };
20454     }
20455   }
20456
20457   jresult = (void *)result;
20458   return jresult;
20459 }
20460
20461
20462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20463   void * jresult ;
20464   Dali::BaseHandle arg1 ;
20465   Dali::BaseHandle *argp1 ;
20466   Dali::Handle result;
20467
20468   argp1 = (Dali::BaseHandle *)jarg1;
20469   if (!argp1) {
20470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20471     return 0;
20472   }
20473   arg1 = *argp1;
20474   {
20475     try {
20476       result = Dali::Handle::DownCast(arg1);
20477     } catch (std::out_of_range& e) {
20478       {
20479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20480       };
20481     } catch (std::exception& e) {
20482       {
20483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20484       };
20485     } catch (Dali::DaliException e) {
20486       {
20487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20488       };
20489     } catch (...) {
20490       {
20491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20492       };
20493     }
20494   }
20495
20496   jresult = new Dali::Handle((const Dali::Handle &)result);
20497   return jresult;
20498 }
20499
20500
20501 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20502   unsigned int jresult ;
20503   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20504   Dali::Handle::Capability arg2 ;
20505   bool result;
20506
20507   arg1 = (Dali::Handle *)jarg1;
20508   arg2 = (Dali::Handle::Capability)jarg2;
20509   {
20510     try {
20511       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20512     } catch (std::out_of_range& e) {
20513       {
20514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20515       };
20516     } catch (std::exception& e) {
20517       {
20518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20519       };
20520     } catch (Dali::DaliException e) {
20521       {
20522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20523       };
20524     } catch (...) {
20525       {
20526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20527       };
20528     }
20529   }
20530
20531   jresult = result;
20532   return jresult;
20533 }
20534
20535
20536 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20537   unsigned int jresult ;
20538   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20539   unsigned int result;
20540
20541   arg1 = (Dali::Handle *)jarg1;
20542   {
20543     try {
20544       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20545     } catch (std::out_of_range& e) {
20546       {
20547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20548       };
20549     } catch (std::exception& e) {
20550       {
20551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20552       };
20553     } catch (Dali::DaliException e) {
20554       {
20555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20556       };
20557     } catch (...) {
20558       {
20559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20560       };
20561     }
20562   }
20563
20564   jresult = result;
20565   return jresult;
20566 }
20567
20568
20569 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20570   char * jresult ;
20571   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20572   Dali::Property::Index arg2 ;
20573   std::string result;
20574
20575   arg1 = (Dali::Handle *)jarg1;
20576   arg2 = (Dali::Property::Index)jarg2;
20577   {
20578     try {
20579       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20580     } catch (std::out_of_range& e) {
20581       {
20582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20583       };
20584     } catch (std::exception& e) {
20585       {
20586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20587       };
20588     } catch (Dali::DaliException e) {
20589       {
20590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20591       };
20592     } catch (...) {
20593       {
20594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20595       };
20596     }
20597   }
20598
20599   jresult = SWIG_csharp_string_callback((&result)->c_str());
20600   return jresult;
20601 }
20602
20603
20604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20605   int jresult ;
20606   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20607   std::string *arg2 = 0 ;
20608   Dali::Property::Index result;
20609
20610   arg1 = (Dali::Handle *)jarg1;
20611   if (!jarg2) {
20612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20613     return 0;
20614   }
20615   std::string arg2_str(jarg2);
20616   arg2 = &arg2_str;
20617   {
20618     try {
20619       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20620     } catch (std::out_of_range& e) {
20621       {
20622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20623       };
20624     } catch (std::exception& e) {
20625       {
20626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20627       };
20628     } catch (Dali::DaliException e) {
20629       {
20630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20631       };
20632     } catch (...) {
20633       {
20634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20635       };
20636     }
20637   }
20638
20639   jresult = result;
20640
20641   //argout typemap for const std::string&
20642
20643   return jresult;
20644 }
20645
20646
20647 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20648   unsigned int jresult ;
20649   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20650   Dali::Property::Index arg2 ;
20651   bool result;
20652
20653   arg1 = (Dali::Handle *)jarg1;
20654   arg2 = (Dali::Property::Index)jarg2;
20655   {
20656     try {
20657       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20658     } catch (std::out_of_range& e) {
20659       {
20660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20661       };
20662     } catch (std::exception& e) {
20663       {
20664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20665       };
20666     } catch (Dali::DaliException e) {
20667       {
20668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20669       };
20670     } catch (...) {
20671       {
20672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20673       };
20674     }
20675   }
20676
20677   jresult = result;
20678   return jresult;
20679 }
20680
20681
20682 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20683   unsigned int jresult ;
20684   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20685   Dali::Property::Index arg2 ;
20686   bool result;
20687
20688   arg1 = (Dali::Handle *)jarg1;
20689   arg2 = (Dali::Property::Index)jarg2;
20690   {
20691     try {
20692       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20693     } catch (std::out_of_range& e) {
20694       {
20695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20696       };
20697     } catch (std::exception& e) {
20698       {
20699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20700       };
20701     } catch (Dali::DaliException e) {
20702       {
20703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20704       };
20705     } catch (...) {
20706       {
20707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20708       };
20709     }
20710   }
20711
20712   jresult = result;
20713   return jresult;
20714 }
20715
20716
20717 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20718   unsigned int jresult ;
20719   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20720   Dali::Property::Index arg2 ;
20721   bool result;
20722
20723   arg1 = (Dali::Handle *)jarg1;
20724   arg2 = (Dali::Property::Index)jarg2;
20725   {
20726     try {
20727       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20728     } catch (std::out_of_range& e) {
20729       {
20730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20731       };
20732     } catch (std::exception& e) {
20733       {
20734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20735       };
20736     } catch (Dali::DaliException e) {
20737       {
20738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20739       };
20740     } catch (...) {
20741       {
20742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20743       };
20744     }
20745   }
20746
20747   jresult = result;
20748   return jresult;
20749 }
20750
20751
20752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20753   int jresult ;
20754   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20755   Dali::Property::Index arg2 ;
20756   Dali::Property::Type result;
20757
20758   arg1 = (Dali::Handle *)jarg1;
20759   arg2 = (Dali::Property::Index)jarg2;
20760   {
20761     try {
20762       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20763     } catch (std::out_of_range& e) {
20764       {
20765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20766       };
20767     } catch (std::exception& e) {
20768       {
20769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20770       };
20771     } catch (Dali::DaliException e) {
20772       {
20773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20774       };
20775     } catch (...) {
20776       {
20777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20778       };
20779     }
20780   }
20781
20782   jresult = (int)result;
20783   return jresult;
20784 }
20785
20786
20787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20788   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20789   Dali::Property::Index arg2 ;
20790   Dali::Property::Value *arg3 = 0 ;
20791
20792   arg1 = (Dali::Handle *)jarg1;
20793   arg2 = (Dali::Property::Index)jarg2;
20794   arg3 = (Dali::Property::Value *)jarg3;
20795   if (!arg3) {
20796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20797     return ;
20798   }
20799   {
20800     try {
20801       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20802     } catch (std::out_of_range& e) {
20803       {
20804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20805       };
20806     } catch (std::exception& e) {
20807       {
20808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20809       };
20810     } catch (Dali::DaliException e) {
20811       {
20812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20813       };
20814     } catch (...) {
20815       {
20816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20817       };
20818     }
20819   }
20820
20821 }
20822
20823
20824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20825   int jresult ;
20826   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20827   std::string *arg2 = 0 ;
20828   Dali::Property::Value *arg3 = 0 ;
20829   Dali::Property::Index result;
20830
20831   arg1 = (Dali::Handle *)jarg1;
20832   if (!jarg2) {
20833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20834     return 0;
20835   }
20836   std::string arg2_str(jarg2);
20837   arg2 = &arg2_str;
20838   arg3 = (Dali::Property::Value *)jarg3;
20839   if (!arg3) {
20840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20841     return 0;
20842   }
20843   {
20844     try {
20845       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20846     } catch (std::out_of_range& e) {
20847       {
20848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20849       };
20850     } catch (std::exception& e) {
20851       {
20852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20853       };
20854     } catch (Dali::DaliException e) {
20855       {
20856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20857       };
20858     } catch (...) {
20859       {
20860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20861       };
20862     }
20863   }
20864
20865   jresult = result;
20866
20867   //argout typemap for const std::string&
20868
20869   return jresult;
20870 }
20871
20872
20873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20874   int jresult ;
20875   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20876   std::string *arg2 = 0 ;
20877   Dali::Property::Value *arg3 = 0 ;
20878   Dali::Property::AccessMode arg4 ;
20879   Dali::Property::Index result;
20880
20881   arg1 = (Dali::Handle *)jarg1;
20882   if (!jarg2) {
20883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20884     return 0;
20885   }
20886   std::string arg2_str(jarg2);
20887   arg2 = &arg2_str;
20888   arg3 = (Dali::Property::Value *)jarg3;
20889   if (!arg3) {
20890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20891     return 0;
20892   }
20893   arg4 = (Dali::Property::AccessMode)jarg4;
20894   {
20895     try {
20896       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20897     } catch (std::out_of_range& e) {
20898       {
20899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20900       };
20901     } catch (std::exception& e) {
20902       {
20903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20904       };
20905     } catch (Dali::DaliException e) {
20906       {
20907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20908       };
20909     } catch (...) {
20910       {
20911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20912       };
20913     }
20914   }
20915
20916   jresult = result;
20917
20918   //argout typemap for const std::string&
20919
20920   return jresult;
20921 }
20922
20923
20924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20925   void * jresult ;
20926   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20927   Dali::Property::Index arg2 ;
20928   Dali::Property::Value result;
20929
20930   arg1 = (Dali::Handle *)jarg1;
20931   arg2 = (Dali::Property::Index)jarg2;
20932   {
20933     try {
20934       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20935     } catch (std::out_of_range& e) {
20936       {
20937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20938       };
20939     } catch (std::exception& e) {
20940       {
20941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20942       };
20943     } catch (Dali::DaliException e) {
20944       {
20945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20946       };
20947     } catch (...) {
20948       {
20949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20950       };
20951     }
20952   }
20953
20954   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20955   return jresult;
20956 }
20957
20958
20959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20960   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20961   Dali::Property::IndexContainer *arg2 = 0 ;
20962
20963   arg1 = (Dali::Handle *)jarg1;
20964   arg2 = (Dali::Property::IndexContainer *)jarg2;
20965   if (!arg2) {
20966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20967     return ;
20968   }
20969   {
20970     try {
20971       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20972     } catch (std::out_of_range& e) {
20973       {
20974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20975       };
20976     } catch (std::exception& e) {
20977       {
20978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20979       };
20980     } catch (Dali::DaliException e) {
20981       {
20982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20983       };
20984     } catch (...) {
20985       {
20986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20987       };
20988     }
20989   }
20990
20991 }
20992
20993
20994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20995   void * jresult ;
20996   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20997   Dali::Property::Index arg2 ;
20998   Dali::PropertyCondition *arg3 = 0 ;
20999   Dali::PropertyNotification result;
21000
21001   arg1 = (Dali::Handle *)jarg1;
21002   arg2 = (Dali::Property::Index)jarg2;
21003   arg3 = (Dali::PropertyCondition *)jarg3;
21004   if (!arg3) {
21005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
21006     return 0;
21007   }
21008   {
21009     try {
21010       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
21011     } catch (std::out_of_range& e) {
21012       {
21013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21014       };
21015     } catch (std::exception& e) {
21016       {
21017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21018       };
21019     } catch (Dali::DaliException e) {
21020       {
21021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21022       };
21023     } catch (...) {
21024       {
21025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21026       };
21027     }
21028   }
21029
21030   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21031   return jresult;
21032 }
21033
21034
21035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
21036   void * jresult ;
21037   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21038   Dali::Property::Index arg2 ;
21039   int arg3 ;
21040   Dali::PropertyCondition *arg4 = 0 ;
21041   Dali::PropertyNotification result;
21042
21043   arg1 = (Dali::Handle *)jarg1;
21044   arg2 = (Dali::Property::Index)jarg2;
21045   arg3 = (int)jarg3;
21046   arg4 = (Dali::PropertyCondition *)jarg4;
21047   if (!arg4) {
21048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
21049     return 0;
21050   }
21051   {
21052     try {
21053       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
21054     } catch (std::out_of_range& e) {
21055       {
21056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21057       };
21058     } catch (std::exception& e) {
21059       {
21060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21061       };
21062     } catch (Dali::DaliException e) {
21063       {
21064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21065       };
21066     } catch (...) {
21067       {
21068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21069       };
21070     }
21071   }
21072
21073   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21074   return jresult;
21075 }
21076
21077
21078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21079   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21080   Dali::PropertyNotification arg2 ;
21081   Dali::PropertyNotification *argp2 ;
21082
21083   arg1 = (Dali::Handle *)jarg1;
21084   argp2 = (Dali::PropertyNotification *)jarg2;
21085   if (!argp2) {
21086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21087     return ;
21088   }
21089   arg2 = *argp2;
21090   {
21091     try {
21092       (arg1)->RemovePropertyNotification(arg2);
21093     } catch (std::out_of_range& e) {
21094       {
21095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21096       };
21097     } catch (std::exception& e) {
21098       {
21099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21100       };
21101     } catch (Dali::DaliException e) {
21102       {
21103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21104       };
21105     } catch (...) {
21106       {
21107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21108       };
21109     }
21110   }
21111
21112 }
21113
21114
21115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21116   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21117
21118   arg1 = (Dali::Handle *)jarg1;
21119   {
21120     try {
21121       (arg1)->RemovePropertyNotifications();
21122     } catch (std::out_of_range& e) {
21123       {
21124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21125       };
21126     } catch (std::exception& e) {
21127       {
21128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21129       };
21130     } catch (Dali::DaliException e) {
21131       {
21132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21133       };
21134     } catch (...) {
21135       {
21136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21137       };
21138     }
21139   }
21140
21141 }
21142
21143
21144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21145   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21146
21147   arg1 = (Dali::Handle *)jarg1;
21148   {
21149     try {
21150       (arg1)->RemoveConstraints();
21151     } catch (std::out_of_range& e) {
21152       {
21153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21154       };
21155     } catch (std::exception& e) {
21156       {
21157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21158       };
21159     } catch (Dali::DaliException e) {
21160       {
21161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21162       };
21163     } catch (...) {
21164       {
21165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21166       };
21167     }
21168   }
21169
21170 }
21171
21172
21173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21174   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21175   unsigned int arg2 ;
21176
21177   arg1 = (Dali::Handle *)jarg1;
21178   arg2 = (unsigned int)jarg2;
21179   {
21180     try {
21181       (arg1)->RemoveConstraints(arg2);
21182     } catch (std::out_of_range& e) {
21183       {
21184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21185       };
21186     } catch (std::exception& e) {
21187       {
21188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21189       };
21190     } catch (Dali::DaliException e) {
21191       {
21192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21193       };
21194     } catch (...) {
21195       {
21196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21197       };
21198     }
21199   }
21200
21201 }
21202
21203
21204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21205   int jresult ;
21206   Dali::Property::Index result;
21207
21208   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21209   jresult = result;
21210   return jresult;
21211 }
21212
21213
21214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21215   void * jresult ;
21216   Dali::Handle result;
21217
21218   {
21219     try {
21220       result = Dali::WeightObject::New();
21221     } catch (std::out_of_range& e) {
21222       {
21223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21224       };
21225     } catch (std::exception& e) {
21226       {
21227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21228       };
21229     } catch (Dali::DaliException e) {
21230       {
21231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21232       };
21233     } catch (...) {
21234       {
21235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21236       };
21237     }
21238   }
21239
21240   jresult = new Dali::Handle((const Dali::Handle &)result);
21241   return jresult;
21242 }
21243
21244
21245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21246   void * jresult ;
21247   Dali::TypeInfo *result = 0 ;
21248
21249   {
21250     try {
21251       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21252     } catch (std::out_of_range& e) {
21253       {
21254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21255       };
21256     } catch (std::exception& e) {
21257       {
21258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21259       };
21260     } catch (Dali::DaliException e) {
21261       {
21262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21263       };
21264     } catch (...) {
21265       {
21266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21267       };
21268     }
21269   }
21270
21271   jresult = (void *)result;
21272   return jresult;
21273 }
21274
21275
21276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21277   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21278
21279   arg1 = (Dali::TypeInfo *)jarg1;
21280   {
21281     try {
21282       delete arg1;
21283     } catch (std::out_of_range& e) {
21284       {
21285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21286       };
21287     } catch (std::exception& e) {
21288       {
21289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21290       };
21291     } catch (Dali::DaliException e) {
21292       {
21293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21294       };
21295     } catch (...) {
21296       {
21297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21298       };
21299     }
21300   }
21301
21302 }
21303
21304
21305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21306   void * jresult ;
21307   Dali::TypeInfo *arg1 = 0 ;
21308   Dali::TypeInfo *result = 0 ;
21309
21310   arg1 = (Dali::TypeInfo *)jarg1;
21311   if (!arg1) {
21312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21313     return 0;
21314   }
21315   {
21316     try {
21317       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21318     } catch (std::out_of_range& e) {
21319       {
21320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21321       };
21322     } catch (std::exception& e) {
21323       {
21324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21325       };
21326     } catch (Dali::DaliException e) {
21327       {
21328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21329       };
21330     } catch (...) {
21331       {
21332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21333       };
21334     }
21335   }
21336
21337   jresult = (void *)result;
21338   return jresult;
21339 }
21340
21341
21342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21343   void * jresult ;
21344   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21345   Dali::TypeInfo *arg2 = 0 ;
21346   Dali::TypeInfo *result = 0 ;
21347
21348   arg1 = (Dali::TypeInfo *)jarg1;
21349   arg2 = (Dali::TypeInfo *)jarg2;
21350   if (!arg2) {
21351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21352     return 0;
21353   }
21354   {
21355     try {
21356       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21357     } catch (std::out_of_range& e) {
21358       {
21359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21360       };
21361     } catch (std::exception& e) {
21362       {
21363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21364       };
21365     } catch (Dali::DaliException e) {
21366       {
21367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21368       };
21369     } catch (...) {
21370       {
21371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21372       };
21373     }
21374   }
21375
21376   jresult = (void *)result;
21377   return jresult;
21378 }
21379
21380
21381 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21382   char * jresult ;
21383   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21384   std::string *result = 0 ;
21385
21386   arg1 = (Dali::TypeInfo *)jarg1;
21387   {
21388     try {
21389       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21390     } catch (std::out_of_range& e) {
21391       {
21392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21393       };
21394     } catch (std::exception& e) {
21395       {
21396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21397       };
21398     } catch (Dali::DaliException e) {
21399       {
21400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21401       };
21402     } catch (...) {
21403       {
21404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21405       };
21406     }
21407   }
21408
21409   jresult = SWIG_csharp_string_callback(result->c_str());
21410   return jresult;
21411 }
21412
21413
21414 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21415   char * jresult ;
21416   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21417   std::string *result = 0 ;
21418
21419   arg1 = (Dali::TypeInfo *)jarg1;
21420   {
21421     try {
21422       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21423     } catch (std::out_of_range& e) {
21424       {
21425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21426       };
21427     } catch (std::exception& e) {
21428       {
21429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21430       };
21431     } catch (Dali::DaliException e) {
21432       {
21433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21434       };
21435     } catch (...) {
21436       {
21437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21438       };
21439     }
21440   }
21441
21442   jresult = SWIG_csharp_string_callback(result->c_str());
21443   return jresult;
21444 }
21445
21446
21447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21448   void * jresult ;
21449   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21450   Dali::BaseHandle result;
21451
21452   arg1 = (Dali::TypeInfo *)jarg1;
21453   {
21454     try {
21455       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21456     } catch (std::out_of_range& e) {
21457       {
21458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21459       };
21460     } catch (std::exception& e) {
21461       {
21462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21463       };
21464     } catch (Dali::DaliException e) {
21465       {
21466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21467       };
21468     } catch (...) {
21469       {
21470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21471       };
21472     }
21473   }
21474
21475   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21476   return jresult;
21477 }
21478
21479
21480 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21481   unsigned long jresult ;
21482   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21483   size_t result;
21484
21485   arg1 = (Dali::TypeInfo *)jarg1;
21486   {
21487     try {
21488       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21489     } catch (std::out_of_range& e) {
21490       {
21491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21492       };
21493     } catch (std::exception& e) {
21494       {
21495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21496       };
21497     } catch (Dali::DaliException e) {
21498       {
21499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21500       };
21501     } catch (...) {
21502       {
21503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21504       };
21505     }
21506   }
21507
21508   jresult = (unsigned long)result;
21509   return jresult;
21510 }
21511
21512
21513 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21514   char * jresult ;
21515   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21516   size_t arg2 ;
21517   std::string result;
21518
21519   arg1 = (Dali::TypeInfo *)jarg1;
21520   arg2 = (size_t)jarg2;
21521   {
21522     try {
21523       result = (arg1)->GetActionName(arg2);
21524     } catch (std::out_of_range& e) {
21525       {
21526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21527       };
21528     } catch (std::exception& e) {
21529       {
21530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21531       };
21532     } catch (Dali::DaliException e) {
21533       {
21534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21535       };
21536     } catch (...) {
21537       {
21538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21539       };
21540     }
21541   }
21542
21543   jresult = SWIG_csharp_string_callback((&result)->c_str());
21544   return jresult;
21545 }
21546
21547
21548 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21549   unsigned long jresult ;
21550   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21551   size_t result;
21552
21553   arg1 = (Dali::TypeInfo *)jarg1;
21554   {
21555     try {
21556       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21557     } catch (std::out_of_range& e) {
21558       {
21559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21560       };
21561     } catch (std::exception& e) {
21562       {
21563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21564       };
21565     } catch (Dali::DaliException e) {
21566       {
21567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21568       };
21569     } catch (...) {
21570       {
21571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21572       };
21573     }
21574   }
21575
21576   jresult = (unsigned long)result;
21577   return jresult;
21578 }
21579
21580
21581 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21582   char * jresult ;
21583   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21584   size_t arg2 ;
21585   std::string result;
21586
21587   arg1 = (Dali::TypeInfo *)jarg1;
21588   arg2 = (size_t)jarg2;
21589   {
21590     try {
21591       result = (arg1)->GetSignalName(arg2);
21592     } catch (std::out_of_range& e) {
21593       {
21594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21595       };
21596     } catch (std::exception& e) {
21597       {
21598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21599       };
21600     } catch (Dali::DaliException e) {
21601       {
21602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21603       };
21604     } catch (...) {
21605       {
21606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21607       };
21608     }
21609   }
21610
21611   jresult = SWIG_csharp_string_callback((&result)->c_str());
21612   return jresult;
21613 }
21614
21615
21616 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21617   unsigned long jresult ;
21618   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21619   size_t result;
21620
21621   arg1 = (Dali::TypeInfo *)jarg1;
21622   {
21623     try {
21624       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21625     } catch (std::out_of_range& e) {
21626       {
21627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21628       };
21629     } catch (std::exception& e) {
21630       {
21631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21632       };
21633     } catch (Dali::DaliException e) {
21634       {
21635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21636       };
21637     } catch (...) {
21638       {
21639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21640       };
21641     }
21642   }
21643
21644   jresult = (unsigned long)result;
21645   return jresult;
21646 }
21647
21648
21649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21650   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21651   Dali::Property::IndexContainer *arg2 = 0 ;
21652
21653   arg1 = (Dali::TypeInfo *)jarg1;
21654   arg2 = (Dali::Property::IndexContainer *)jarg2;
21655   if (!arg2) {
21656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21657     return ;
21658   }
21659   {
21660     try {
21661       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21662     } catch (std::out_of_range& e) {
21663       {
21664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21665       };
21666     } catch (std::exception& e) {
21667       {
21668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21669       };
21670     } catch (Dali::DaliException e) {
21671       {
21672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21673       };
21674     } catch (...) {
21675       {
21676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21677       };
21678     }
21679   }
21680
21681 }
21682
21683
21684 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21685   char * jresult ;
21686   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21687   Dali::Property::Index arg2 ;
21688   std::string *result = 0 ;
21689
21690   arg1 = (Dali::TypeInfo *)jarg1;
21691   arg2 = (Dali::Property::Index)jarg2;
21692   {
21693     try {
21694       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21695     } catch (std::out_of_range& e) {
21696       {
21697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21698       };
21699     } catch (std::exception& e) {
21700       {
21701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21702       };
21703     } catch (Dali::DaliException e) {
21704       {
21705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21706       };
21707     } catch (...) {
21708       {
21709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21710       };
21711     }
21712   }
21713
21714   jresult = SWIG_csharp_string_callback(result->c_str());
21715   return jresult;
21716 }
21717
21718
21719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21720   void * jresult ;
21721   Dali::TypeRegistry result;
21722
21723   {
21724     try {
21725       result = Dali::TypeRegistry::Get();
21726     } catch (std::out_of_range& e) {
21727       {
21728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21729       };
21730     } catch (std::exception& e) {
21731       {
21732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21733       };
21734     } catch (Dali::DaliException e) {
21735       {
21736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21737       };
21738     } catch (...) {
21739       {
21740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21741       };
21742     }
21743   }
21744
21745   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21746   return jresult;
21747 }
21748
21749
21750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21751   void * jresult ;
21752   Dali::TypeRegistry *result = 0 ;
21753
21754   {
21755     try {
21756       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21757     } catch (std::out_of_range& e) {
21758       {
21759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21760       };
21761     } catch (std::exception& e) {
21762       {
21763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21764       };
21765     } catch (Dali::DaliException e) {
21766       {
21767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21768       };
21769     } catch (...) {
21770       {
21771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21772       };
21773     }
21774   }
21775
21776   jresult = (void *)result;
21777   return jresult;
21778 }
21779
21780
21781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21782   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21783
21784   arg1 = (Dali::TypeRegistry *)jarg1;
21785   {
21786     try {
21787       delete arg1;
21788     } catch (std::out_of_range& e) {
21789       {
21790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21791       };
21792     } catch (std::exception& e) {
21793       {
21794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21795       };
21796     } catch (Dali::DaliException e) {
21797       {
21798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21799       };
21800     } catch (...) {
21801       {
21802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21803       };
21804     }
21805   }
21806
21807 }
21808
21809
21810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21811   void * jresult ;
21812   Dali::TypeRegistry *arg1 = 0 ;
21813   Dali::TypeRegistry *result = 0 ;
21814
21815   arg1 = (Dali::TypeRegistry *)jarg1;
21816   if (!arg1) {
21817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21818     return 0;
21819   }
21820   {
21821     try {
21822       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21823     } catch (std::out_of_range& e) {
21824       {
21825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21826       };
21827     } catch (std::exception& e) {
21828       {
21829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21830       };
21831     } catch (Dali::DaliException e) {
21832       {
21833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21834       };
21835     } catch (...) {
21836       {
21837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21838       };
21839     }
21840   }
21841
21842   jresult = (void *)result;
21843   return jresult;
21844 }
21845
21846
21847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21848   void * jresult ;
21849   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21850   Dali::TypeRegistry *arg2 = 0 ;
21851   Dali::TypeRegistry *result = 0 ;
21852
21853   arg1 = (Dali::TypeRegistry *)jarg1;
21854   arg2 = (Dali::TypeRegistry *)jarg2;
21855   if (!arg2) {
21856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21857     return 0;
21858   }
21859   {
21860     try {
21861       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21862     } catch (std::out_of_range& e) {
21863       {
21864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21865       };
21866     } catch (std::exception& e) {
21867       {
21868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21869       };
21870     } catch (Dali::DaliException e) {
21871       {
21872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21873       };
21874     } catch (...) {
21875       {
21876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21877       };
21878     }
21879   }
21880
21881   jresult = (void *)result;
21882   return jresult;
21883 }
21884
21885
21886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21887   void * jresult ;
21888   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21889   std::string *arg2 = 0 ;
21890   Dali::TypeInfo result;
21891
21892   arg1 = (Dali::TypeRegistry *)jarg1;
21893   if (!jarg2) {
21894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21895     return 0;
21896   }
21897   std::string arg2_str(jarg2);
21898   arg2 = &arg2_str;
21899   {
21900     try {
21901       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21902     } catch (std::out_of_range& e) {
21903       {
21904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21905       };
21906     } catch (std::exception& e) {
21907       {
21908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21909       };
21910     } catch (Dali::DaliException e) {
21911       {
21912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21913       };
21914     } catch (...) {
21915       {
21916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21917       };
21918     }
21919   }
21920
21921   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21922
21923   //argout typemap for const std::string&
21924
21925   return jresult;
21926 }
21927
21928
21929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21930   void * jresult ;
21931   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21932   std::type_info *arg2 = 0 ;
21933   Dali::TypeInfo result;
21934
21935   arg1 = (Dali::TypeRegistry *)jarg1;
21936   arg2 = (std::type_info *)jarg2;
21937   if (!arg2) {
21938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21939     return 0;
21940   }
21941   {
21942     try {
21943       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21944     } catch (std::out_of_range& e) {
21945       {
21946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21947       };
21948     } catch (std::exception& e) {
21949       {
21950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21951       };
21952     } catch (Dali::DaliException e) {
21953       {
21954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21955       };
21956     } catch (...) {
21957       {
21958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21959       };
21960     }
21961   }
21962
21963   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21964   return jresult;
21965 }
21966
21967
21968 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21969   unsigned long jresult ;
21970   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21971   size_t result;
21972
21973   arg1 = (Dali::TypeRegistry *)jarg1;
21974   {
21975     try {
21976       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21977     } catch (std::out_of_range& e) {
21978       {
21979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21980       };
21981     } catch (std::exception& e) {
21982       {
21983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21984       };
21985     } catch (Dali::DaliException e) {
21986       {
21987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21988       };
21989     } catch (...) {
21990       {
21991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21992       };
21993     }
21994   }
21995
21996   jresult = (unsigned long)result;
21997   return jresult;
21998 }
21999
22000
22001 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
22002   char * jresult ;
22003   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
22004   size_t arg2 ;
22005   std::string result;
22006
22007   arg1 = (Dali::TypeRegistry *)jarg1;
22008   arg2 = (size_t)jarg2;
22009   {
22010     try {
22011       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
22012     } catch (std::out_of_range& e) {
22013       {
22014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22015       };
22016     } catch (std::exception& e) {
22017       {
22018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22019       };
22020     } catch (Dali::DaliException e) {
22021       {
22022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22023       };
22024     } catch (...) {
22025       {
22026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22027       };
22028     }
22029   }
22030
22031   jresult = SWIG_csharp_string_callback((&result)->c_str());
22032   return jresult;
22033 }
22034
22035
22036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
22037   void * jresult ;
22038   std::type_info *arg1 = 0 ;
22039   std::type_info *arg2 = 0 ;
22040   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22041   Dali::TypeRegistration *result = 0 ;
22042
22043   arg1 = (std::type_info *)jarg1;
22044   if (!arg1) {
22045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22046     return 0;
22047   }
22048   arg2 = (std::type_info *)jarg2;
22049   if (!arg2) {
22050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22051     return 0;
22052   }
22053   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22054   {
22055     try {
22056       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
22057     } catch (std::out_of_range& e) {
22058       {
22059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22060       };
22061     } catch (std::exception& e) {
22062       {
22063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22064       };
22065     } catch (Dali::DaliException e) {
22066       {
22067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22068       };
22069     } catch (...) {
22070       {
22071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22072       };
22073     }
22074   }
22075
22076   jresult = (void *)result;
22077   return jresult;
22078 }
22079
22080
22081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22082   void * jresult ;
22083   std::type_info *arg1 = 0 ;
22084   std::type_info *arg2 = 0 ;
22085   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22086   bool arg4 ;
22087   Dali::TypeRegistration *result = 0 ;
22088
22089   arg1 = (std::type_info *)jarg1;
22090   if (!arg1) {
22091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22092     return 0;
22093   }
22094   arg2 = (std::type_info *)jarg2;
22095   if (!arg2) {
22096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22097     return 0;
22098   }
22099   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22100   arg4 = jarg4 ? true : false;
22101   {
22102     try {
22103       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22104     } catch (std::out_of_range& e) {
22105       {
22106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22107       };
22108     } catch (std::exception& e) {
22109       {
22110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22111       };
22112     } catch (Dali::DaliException e) {
22113       {
22114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22115       };
22116     } catch (...) {
22117       {
22118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22119       };
22120     }
22121   }
22122
22123   jresult = (void *)result;
22124   return jresult;
22125 }
22126
22127
22128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22129   void * jresult ;
22130   std::string *arg1 = 0 ;
22131   std::type_info *arg2 = 0 ;
22132   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22133   Dali::TypeRegistration *result = 0 ;
22134
22135   if (!jarg1) {
22136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22137     return 0;
22138   }
22139   std::string arg1_str(jarg1);
22140   arg1 = &arg1_str;
22141   arg2 = (std::type_info *)jarg2;
22142   if (!arg2) {
22143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22144     return 0;
22145   }
22146   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22147   {
22148     try {
22149       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22150     } catch (std::out_of_range& e) {
22151       {
22152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22153       };
22154     } catch (std::exception& e) {
22155       {
22156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22157       };
22158     } catch (Dali::DaliException e) {
22159       {
22160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22161       };
22162     } catch (...) {
22163       {
22164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22165       };
22166     }
22167   }
22168
22169   jresult = (void *)result;
22170
22171   //argout typemap for const std::string&
22172
22173   return jresult;
22174 }
22175
22176
22177 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22178   char * jresult ;
22179   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22180   std::string result;
22181
22182   arg1 = (Dali::TypeRegistration *)jarg1;
22183   {
22184     try {
22185       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22186     } catch (std::out_of_range& e) {
22187       {
22188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22189       };
22190     } catch (std::exception& e) {
22191       {
22192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22193       };
22194     } catch (Dali::DaliException e) {
22195       {
22196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22197       };
22198     } catch (...) {
22199       {
22200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22201       };
22202     }
22203   }
22204
22205   jresult = SWIG_csharp_string_callback((&result)->c_str());
22206   return jresult;
22207 }
22208
22209
22210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22211   std::string *arg1 = 0 ;
22212   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22213
22214   if (!jarg1) {
22215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22216     return ;
22217   }
22218   std::string arg1_str(jarg1);
22219   arg1 = &arg1_str;
22220   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22221   {
22222     try {
22223       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22224     } catch (std::out_of_range& e) {
22225       {
22226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22227       };
22228     } catch (std::exception& e) {
22229       {
22230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22231       };
22232     } catch (Dali::DaliException e) {
22233       {
22234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22235       };
22236     } catch (...) {
22237       {
22238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22239       };
22240     }
22241   }
22242
22243
22244   //argout typemap for const std::string&
22245
22246 }
22247
22248
22249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22250   std::string *arg1 = 0 ;
22251   std::string *arg2 = 0 ;
22252   int arg3 ;
22253   Dali::Property::Type arg4 ;
22254   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22255   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22256
22257   if (!jarg1) {
22258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22259     return ;
22260   }
22261   std::string arg1_str(jarg1);
22262   arg1 = &arg1_str;
22263   if (!jarg2) {
22264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22265     return ;
22266   }
22267   std::string arg2_str(jarg2);
22268   arg2 = &arg2_str;
22269   arg3 = (int)jarg3;
22270   arg4 = (Dali::Property::Type)jarg4;
22271   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22272   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22273   {
22274     try {
22275       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22276     } catch (std::out_of_range& e) {
22277       {
22278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22279       };
22280     } catch (std::exception& e) {
22281       {
22282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22283       };
22284     } catch (Dali::DaliException e) {
22285       {
22286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22287       };
22288     } catch (...) {
22289       {
22290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22291       };
22292     }
22293   }
22294
22295
22296   //argout typemap for const std::string&
22297
22298
22299   //argout typemap for const std::string&
22300
22301 }
22302
22303
22304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22305   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22306
22307   arg1 = (Dali::TypeRegistration *)jarg1;
22308   {
22309     try {
22310       delete arg1;
22311     } catch (std::out_of_range& e) {
22312       {
22313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22314       };
22315     } catch (std::exception& e) {
22316       {
22317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22318       };
22319     } catch (Dali::DaliException e) {
22320       {
22321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22322       };
22323     } catch (...) {
22324       {
22325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22326       };
22327     }
22328   }
22329
22330 }
22331
22332
22333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22334   void * jresult ;
22335   Dali::TypeRegistration *arg1 = 0 ;
22336   std::string *arg2 = 0 ;
22337   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22338   Dali::SignalConnectorType *result = 0 ;
22339
22340   arg1 = (Dali::TypeRegistration *)jarg1;
22341   if (!arg1) {
22342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22343     return 0;
22344   }
22345   if (!jarg2) {
22346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22347     return 0;
22348   }
22349   std::string arg2_str(jarg2);
22350   arg2 = &arg2_str;
22351   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22352   {
22353     try {
22354       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22355     } catch (std::out_of_range& e) {
22356       {
22357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22358       };
22359     } catch (std::exception& e) {
22360       {
22361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22362       };
22363     } catch (Dali::DaliException e) {
22364       {
22365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22366       };
22367     } catch (...) {
22368       {
22369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22370       };
22371     }
22372   }
22373
22374   jresult = (void *)result;
22375
22376   //argout typemap for const std::string&
22377
22378   return jresult;
22379 }
22380
22381
22382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22383   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22384
22385   arg1 = (Dali::SignalConnectorType *)jarg1;
22386   {
22387     try {
22388       delete arg1;
22389     } catch (std::out_of_range& e) {
22390       {
22391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22392       };
22393     } catch (std::exception& e) {
22394       {
22395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22396       };
22397     } catch (Dali::DaliException e) {
22398       {
22399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22400       };
22401     } catch (...) {
22402       {
22403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22404       };
22405     }
22406   }
22407
22408 }
22409
22410
22411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22412   void * jresult ;
22413   Dali::TypeRegistration *arg1 = 0 ;
22414   std::string *arg2 = 0 ;
22415   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22416   Dali::TypeAction *result = 0 ;
22417
22418   arg1 = (Dali::TypeRegistration *)jarg1;
22419   if (!arg1) {
22420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22421     return 0;
22422   }
22423   if (!jarg2) {
22424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22425     return 0;
22426   }
22427   std::string arg2_str(jarg2);
22428   arg2 = &arg2_str;
22429   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22430   {
22431     try {
22432       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22433     } catch (std::out_of_range& e) {
22434       {
22435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22436       };
22437     } catch (std::exception& e) {
22438       {
22439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22440       };
22441     } catch (Dali::DaliException e) {
22442       {
22443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22444       };
22445     } catch (...) {
22446       {
22447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22448       };
22449     }
22450   }
22451
22452   jresult = (void *)result;
22453
22454   //argout typemap for const std::string&
22455
22456   return jresult;
22457 }
22458
22459
22460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22461   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22462
22463   arg1 = (Dali::TypeAction *)jarg1;
22464   {
22465     try {
22466       delete arg1;
22467     } catch (std::out_of_range& e) {
22468       {
22469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22470       };
22471     } catch (std::exception& e) {
22472       {
22473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22474       };
22475     } catch (Dali::DaliException e) {
22476       {
22477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22478       };
22479     } catch (...) {
22480       {
22481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22482       };
22483     }
22484   }
22485
22486 }
22487
22488
22489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22490   void * jresult ;
22491   Dali::TypeRegistration *arg1 = 0 ;
22492   std::string *arg2 = 0 ;
22493   Dali::Property::Index arg3 ;
22494   Dali::Property::Type arg4 ;
22495   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22496   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22497   Dali::PropertyRegistration *result = 0 ;
22498
22499   arg1 = (Dali::TypeRegistration *)jarg1;
22500   if (!arg1) {
22501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22502     return 0;
22503   }
22504   if (!jarg2) {
22505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22506     return 0;
22507   }
22508   std::string arg2_str(jarg2);
22509   arg2 = &arg2_str;
22510   arg3 = (Dali::Property::Index)jarg3;
22511   arg4 = (Dali::Property::Type)jarg4;
22512   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22513   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22514   {
22515     try {
22516       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22517     } catch (std::out_of_range& e) {
22518       {
22519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22520       };
22521     } catch (std::exception& e) {
22522       {
22523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22524       };
22525     } catch (Dali::DaliException e) {
22526       {
22527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22528       };
22529     } catch (...) {
22530       {
22531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22532       };
22533     }
22534   }
22535
22536   jresult = (void *)result;
22537
22538   //argout typemap for const std::string&
22539
22540   return jresult;
22541 }
22542
22543
22544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22545   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22546
22547   arg1 = (Dali::PropertyRegistration *)jarg1;
22548   {
22549     try {
22550       delete arg1;
22551     } catch (std::out_of_range& e) {
22552       {
22553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22554       };
22555     } catch (std::exception& e) {
22556       {
22557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22558       };
22559     } catch (Dali::DaliException e) {
22560       {
22561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22562       };
22563     } catch (...) {
22564       {
22565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22566       };
22567     }
22568   }
22569
22570 }
22571
22572
22573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22574   void * jresult ;
22575   Dali::TypeRegistration *arg1 = 0 ;
22576   std::string *arg2 = 0 ;
22577   Dali::Property::Index arg3 ;
22578   Dali::Property::Type arg4 ;
22579   Dali::AnimatablePropertyRegistration *result = 0 ;
22580
22581   arg1 = (Dali::TypeRegistration *)jarg1;
22582   if (!arg1) {
22583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22584     return 0;
22585   }
22586   if (!jarg2) {
22587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22588     return 0;
22589   }
22590   std::string arg2_str(jarg2);
22591   arg2 = &arg2_str;
22592   arg3 = (Dali::Property::Index)jarg3;
22593   arg4 = (Dali::Property::Type)jarg4;
22594   {
22595     try {
22596       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22597     } catch (std::out_of_range& e) {
22598       {
22599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22600       };
22601     } catch (std::exception& e) {
22602       {
22603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22604       };
22605     } catch (Dali::DaliException e) {
22606       {
22607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22608       };
22609     } catch (...) {
22610       {
22611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22612       };
22613     }
22614   }
22615
22616   jresult = (void *)result;
22617
22618   //argout typemap for const std::string&
22619
22620   return jresult;
22621 }
22622
22623
22624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22625   void * jresult ;
22626   Dali::TypeRegistration *arg1 = 0 ;
22627   std::string *arg2 = 0 ;
22628   Dali::Property::Index arg3 ;
22629   Dali::Property::Value *arg4 = 0 ;
22630   Dali::AnimatablePropertyRegistration *result = 0 ;
22631
22632   arg1 = (Dali::TypeRegistration *)jarg1;
22633   if (!arg1) {
22634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22635     return 0;
22636   }
22637   if (!jarg2) {
22638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22639     return 0;
22640   }
22641   std::string arg2_str(jarg2);
22642   arg2 = &arg2_str;
22643   arg3 = (Dali::Property::Index)jarg3;
22644   arg4 = (Dali::Property::Value *)jarg4;
22645   if (!arg4) {
22646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22647     return 0;
22648   }
22649   {
22650     try {
22651       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22652     } catch (std::out_of_range& e) {
22653       {
22654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22655       };
22656     } catch (std::exception& e) {
22657       {
22658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22659       };
22660     } catch (Dali::DaliException e) {
22661       {
22662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22663       };
22664     } catch (...) {
22665       {
22666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22667       };
22668     }
22669   }
22670
22671   jresult = (void *)result;
22672
22673   //argout typemap for const std::string&
22674
22675   return jresult;
22676 }
22677
22678
22679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22680   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22681
22682   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22683   {
22684     try {
22685       delete arg1;
22686     } catch (std::out_of_range& e) {
22687       {
22688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22689       };
22690     } catch (std::exception& e) {
22691       {
22692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22693       };
22694     } catch (Dali::DaliException e) {
22695       {
22696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22697       };
22698     } catch (...) {
22699       {
22700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22701       };
22702     }
22703   }
22704
22705 }
22706
22707
22708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22709   void * jresult ;
22710   Dali::TypeRegistration *arg1 = 0 ;
22711   std::string *arg2 = 0 ;
22712   Dali::Property::Index arg3 ;
22713   Dali::Property::Index arg4 ;
22714   unsigned int arg5 ;
22715   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22716
22717   arg1 = (Dali::TypeRegistration *)jarg1;
22718   if (!arg1) {
22719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22720     return 0;
22721   }
22722   if (!jarg2) {
22723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22724     return 0;
22725   }
22726   std::string arg2_str(jarg2);
22727   arg2 = &arg2_str;
22728   arg3 = (Dali::Property::Index)jarg3;
22729   arg4 = (Dali::Property::Index)jarg4;
22730   arg5 = (unsigned int)jarg5;
22731   {
22732     try {
22733       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22734     } catch (std::out_of_range& e) {
22735       {
22736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22737       };
22738     } catch (std::exception& e) {
22739       {
22740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22741       };
22742     } catch (Dali::DaliException e) {
22743       {
22744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22745       };
22746     } catch (...) {
22747       {
22748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22749       };
22750     }
22751   }
22752
22753   jresult = (void *)result;
22754
22755   //argout typemap for const std::string&
22756
22757   return jresult;
22758 }
22759
22760
22761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22762   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22763
22764   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22765   {
22766     try {
22767       delete arg1;
22768     } catch (std::out_of_range& e) {
22769       {
22770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22771       };
22772     } catch (std::exception& e) {
22773       {
22774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22775       };
22776     } catch (Dali::DaliException e) {
22777       {
22778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22779       };
22780     } catch (...) {
22781       {
22782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22783       };
22784     }
22785   }
22786
22787 }
22788
22789
22790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22791   void * jresult ;
22792   Dali::TypeRegistration *arg1 = 0 ;
22793   std::string *arg2 = 0 ;
22794   Dali::Property::Index arg3 ;
22795   Dali::Property::Type arg4 ;
22796   Dali::ChildPropertyRegistration *result = 0 ;
22797
22798   arg1 = (Dali::TypeRegistration *)jarg1;
22799   if (!arg1) {
22800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22801     return 0;
22802   }
22803   if (!jarg2) {
22804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22805     return 0;
22806   }
22807   std::string arg2_str(jarg2);
22808   arg2 = &arg2_str;
22809   arg3 = (Dali::Property::Index)jarg3;
22810   arg4 = (Dali::Property::Type)jarg4;
22811   {
22812     try {
22813       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22814     } catch (std::out_of_range& e) {
22815       {
22816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22817       };
22818     } catch (std::exception& e) {
22819       {
22820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22821       };
22822     } catch (Dali::DaliException e) {
22823       {
22824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22825       };
22826     } catch (...) {
22827       {
22828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22829       };
22830     }
22831   }
22832
22833   jresult = (void *)result;
22834
22835   //argout typemap for const std::string&
22836
22837   return jresult;
22838 }
22839
22840
22841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22842   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22843
22844   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22845   {
22846     try {
22847       delete arg1;
22848     } catch (std::out_of_range& e) {
22849       {
22850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22851       };
22852     } catch (std::exception& e) {
22853       {
22854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22855       };
22856     } catch (Dali::DaliException e) {
22857       {
22858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22859       };
22860     } catch (...) {
22861       {
22862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22863       };
22864     }
22865   }
22866
22867 }
22868
22869
22870 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22871   unsigned int jresult ;
22872   std::string *arg1 = 0 ;
22873   std::type_info *arg2 = 0 ;
22874   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22875   bool result;
22876
22877   if (!jarg1) {
22878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22879     return 0;
22880   }
22881   std::string arg1_str(jarg1);
22882   arg1 = &arg1_str;
22883   arg2 = (std::type_info *)jarg2;
22884   if (!arg2) {
22885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22886     return 0;
22887   }
22888   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22889   {
22890     try {
22891       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22892     } catch (std::out_of_range& e) {
22893       {
22894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22895       };
22896     } catch (std::exception& e) {
22897       {
22898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22899       };
22900     } catch (Dali::DaliException e) {
22901       {
22902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22903       };
22904     } catch (...) {
22905       {
22906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22907       };
22908     }
22909   }
22910
22911   jresult = result;
22912
22913   //argout typemap for const std::string&
22914
22915   return jresult;
22916 }
22917
22918
22919 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22920   unsigned int jresult ;
22921   std::string *arg1 = 0 ;
22922   std::string *arg2 = 0 ;
22923   Dali::Property::Index arg3 ;
22924   Dali::Property::Type arg4 ;
22925   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22926   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22927   bool result;
22928
22929   if (!jarg1) {
22930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22931     return 0;
22932   }
22933   std::string arg1_str(jarg1);
22934   arg1 = &arg1_str;
22935   if (!jarg2) {
22936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22937     return 0;
22938   }
22939   std::string arg2_str(jarg2);
22940   arg2 = &arg2_str;
22941   arg3 = (Dali::Property::Index)jarg3;
22942   arg4 = (Dali::Property::Type)jarg4;
22943   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22944   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22945   {
22946     try {
22947       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22948     } catch (std::out_of_range& e) {
22949       {
22950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22951       };
22952     } catch (std::exception& e) {
22953       {
22954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22955       };
22956     } catch (Dali::DaliException e) {
22957       {
22958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22959       };
22960     } catch (...) {
22961       {
22962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22963       };
22964     }
22965   }
22966
22967   jresult = result;
22968
22969   //argout typemap for const std::string&
22970
22971
22972   //argout typemap for const std::string&
22973
22974   return jresult;
22975 }
22976
22977
22978 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22979   float jresult ;
22980   float result;
22981
22982   result = (float)(float)Dali::ParentOrigin::TOP;
22983   jresult = result;
22984   return jresult;
22985 }
22986
22987
22988 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22989   float jresult ;
22990   float result;
22991
22992   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22993   jresult = result;
22994   return jresult;
22995 }
22996
22997
22998 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22999   float jresult ;
23000   float result;
23001
23002   result = (float)(float)Dali::ParentOrigin::LEFT;
23003   jresult = result;
23004   return jresult;
23005 }
23006
23007
23008 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
23009   float jresult ;
23010   float result;
23011
23012   result = (float)(float)Dali::ParentOrigin::RIGHT;
23013   jresult = result;
23014   return jresult;
23015 }
23016
23017
23018 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
23019   float jresult ;
23020   float result;
23021
23022   result = (float)(float)Dali::ParentOrigin::MIDDLE;
23023   jresult = result;
23024   return jresult;
23025 }
23026
23027
23028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
23029   void * jresult ;
23030   Dali::Vector3 *result = 0 ;
23031
23032   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
23033   jresult = (void *)result;
23034   return jresult;
23035 }
23036
23037
23038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
23039   void * jresult ;
23040   Dali::Vector3 *result = 0 ;
23041
23042   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
23043   jresult = (void *)result;
23044   return jresult;
23045 }
23046
23047
23048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
23049   void * jresult ;
23050   Dali::Vector3 *result = 0 ;
23051
23052   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
23053   jresult = (void *)result;
23054   return jresult;
23055 }
23056
23057
23058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
23059   void * jresult ;
23060   Dali::Vector3 *result = 0 ;
23061
23062   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
23063   jresult = (void *)result;
23064   return jresult;
23065 }
23066
23067
23068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
23069   void * jresult ;
23070   Dali::Vector3 *result = 0 ;
23071
23072   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23073   jresult = (void *)result;
23074   return jresult;
23075 }
23076
23077
23078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23079   void * jresult ;
23080   Dali::Vector3 *result = 0 ;
23081
23082   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23083   jresult = (void *)result;
23084   return jresult;
23085 }
23086
23087
23088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23089   void * jresult ;
23090   Dali::Vector3 *result = 0 ;
23091
23092   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23093   jresult = (void *)result;
23094   return jresult;
23095 }
23096
23097
23098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23099   void * jresult ;
23100   Dali::Vector3 *result = 0 ;
23101
23102   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23103   jresult = (void *)result;
23104   return jresult;
23105 }
23106
23107
23108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23109   void * jresult ;
23110   Dali::Vector3 *result = 0 ;
23111
23112   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23113   jresult = (void *)result;
23114   return jresult;
23115 }
23116
23117
23118 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23119   float jresult ;
23120   float result;
23121
23122   result = (float)(float)Dali::AnchorPoint::TOP;
23123   jresult = result;
23124   return jresult;
23125 }
23126
23127
23128 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23129   float jresult ;
23130   float result;
23131
23132   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23133   jresult = result;
23134   return jresult;
23135 }
23136
23137
23138 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23139   float jresult ;
23140   float result;
23141
23142   result = (float)(float)Dali::AnchorPoint::LEFT;
23143   jresult = result;
23144   return jresult;
23145 }
23146
23147
23148 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23149   float jresult ;
23150   float result;
23151
23152   result = (float)(float)Dali::AnchorPoint::RIGHT;
23153   jresult = result;
23154   return jresult;
23155 }
23156
23157
23158 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23159   float jresult ;
23160   float result;
23161
23162   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23163   jresult = result;
23164   return jresult;
23165 }
23166
23167
23168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23169   void * jresult ;
23170   Dali::Vector3 *result = 0 ;
23171
23172   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23173   jresult = (void *)result;
23174   return jresult;
23175 }
23176
23177
23178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23179   void * jresult ;
23180   Dali::Vector3 *result = 0 ;
23181
23182   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23183   jresult = (void *)result;
23184   return jresult;
23185 }
23186
23187
23188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23189   void * jresult ;
23190   Dali::Vector3 *result = 0 ;
23191
23192   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23193   jresult = (void *)result;
23194   return jresult;
23195 }
23196
23197
23198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23199   void * jresult ;
23200   Dali::Vector3 *result = 0 ;
23201
23202   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23203   jresult = (void *)result;
23204   return jresult;
23205 }
23206
23207
23208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23209   void * jresult ;
23210   Dali::Vector3 *result = 0 ;
23211
23212   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23213   jresult = (void *)result;
23214   return jresult;
23215 }
23216
23217
23218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23219   void * jresult ;
23220   Dali::Vector3 *result = 0 ;
23221
23222   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23223   jresult = (void *)result;
23224   return jresult;
23225 }
23226
23227
23228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23229   void * jresult ;
23230   Dali::Vector3 *result = 0 ;
23231
23232   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23233   jresult = (void *)result;
23234   return jresult;
23235 }
23236
23237
23238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23239   void * jresult ;
23240   Dali::Vector3 *result = 0 ;
23241
23242   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23243   jresult = (void *)result;
23244   return jresult;
23245 }
23246
23247
23248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23249   void * jresult ;
23250   Dali::Vector3 *result = 0 ;
23251
23252   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23253   jresult = (void *)result;
23254   return jresult;
23255 }
23256
23257
23258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23259   void * jresult ;
23260   Dali::Vector4 *result = 0 ;
23261
23262   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23263   jresult = (void *)result;
23264   return jresult;
23265 }
23266
23267
23268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23269   void * jresult ;
23270   Dali::Vector4 *result = 0 ;
23271
23272   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23273   jresult = (void *)result;
23274   return jresult;
23275 }
23276
23277
23278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23279   void * jresult ;
23280   Dali::Vector4 *result = 0 ;
23281
23282   result = (Dali::Vector4 *)&Dali::Color::RED;
23283   jresult = (void *)result;
23284   return jresult;
23285 }
23286
23287
23288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23289   void * jresult ;
23290   Dali::Vector4 *result = 0 ;
23291
23292   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23293   jresult = (void *)result;
23294   return jresult;
23295 }
23296
23297
23298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23299   void * jresult ;
23300   Dali::Vector4 *result = 0 ;
23301
23302   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23303   jresult = (void *)result;
23304   return jresult;
23305 }
23306
23307
23308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23309   void * jresult ;
23310   Dali::Vector4 *result = 0 ;
23311
23312   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23313   jresult = (void *)result;
23314   return jresult;
23315 }
23316
23317
23318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23319   void * jresult ;
23320   Dali::Vector4 *result = 0 ;
23321
23322   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23323   jresult = (void *)result;
23324   return jresult;
23325 }
23326
23327
23328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23329   void * jresult ;
23330   Dali::Vector4 *result = 0 ;
23331
23332   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23333   jresult = (void *)result;
23334   return jresult;
23335 }
23336
23337
23338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23339   void * jresult ;
23340   Dali::Vector4 *result = 0 ;
23341
23342   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23343   jresult = (void *)result;
23344   return jresult;
23345 }
23346
23347
23348 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23349   float jresult ;
23350   float result;
23351
23352   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23353   jresult = result;
23354   return jresult;
23355 }
23356
23357
23358 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23359   float jresult ;
23360   float result;
23361
23362   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23363   jresult = result;
23364   return jresult;
23365 }
23366
23367
23368 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23369   float jresult ;
23370   float result;
23371
23372   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23373   jresult = result;
23374   return jresult;
23375 }
23376
23377
23378 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23379   float jresult ;
23380   float result;
23381
23382   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23383   jresult = result;
23384   return jresult;
23385 }
23386
23387
23388 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23389   float jresult ;
23390   float result;
23391
23392   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23393   jresult = result;
23394   return jresult;
23395 }
23396
23397
23398 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23399   float jresult ;
23400   float result;
23401
23402   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23403   jresult = result;
23404   return jresult;
23405 }
23406
23407
23408 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23409   float jresult ;
23410   float result;
23411
23412   result = (float)(float)Dali::Math::PI;
23413   jresult = result;
23414   return jresult;
23415 }
23416
23417
23418 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23419   float jresult ;
23420   float result;
23421
23422   result = (float)(float)Dali::Math::PI_2;
23423   jresult = result;
23424   return jresult;
23425 }
23426
23427
23428 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23429   float jresult ;
23430   float result;
23431
23432   result = (float)(float)Dali::Math::PI_4;
23433   jresult = result;
23434   return jresult;
23435 }
23436
23437
23438 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23439   float jresult ;
23440   float result;
23441
23442   result = (float)(float)Dali::Math::PI_OVER_180;
23443   jresult = result;
23444   return jresult;
23445 }
23446
23447
23448 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23449   float jresult ;
23450   float result;
23451
23452   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23453   jresult = result;
23454   return jresult;
23455 }
23456
23457
23458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23459   int jresult ;
23460   Dali::ResizePolicy::Type result;
23461
23462   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23463   jresult = (int)result;
23464   return jresult;
23465 }
23466
23467
23468 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23469   unsigned long jresult ;
23470   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23471   Dali::VectorBase::SizeType result;
23472
23473   arg1 = (Dali::VectorBase *)jarg1;
23474   {
23475     try {
23476       result = ((Dali::VectorBase const *)arg1)->Count();
23477     } catch (std::out_of_range& e) {
23478       {
23479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23480       };
23481     } catch (std::exception& e) {
23482       {
23483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23484       };
23485     } catch (Dali::DaliException e) {
23486       {
23487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23488       };
23489     } catch (...) {
23490       {
23491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23492       };
23493     }
23494   }
23495
23496   jresult = (unsigned long)result;
23497   return jresult;
23498 }
23499
23500
23501 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23502   unsigned long jresult ;
23503   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23504   Dali::VectorBase::SizeType result;
23505
23506   arg1 = (Dali::VectorBase *)jarg1;
23507   {
23508     try {
23509       result = ((Dali::VectorBase const *)arg1)->Size();
23510     } catch (std::out_of_range& e) {
23511       {
23512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23513       };
23514     } catch (std::exception& e) {
23515       {
23516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23517       };
23518     } catch (Dali::DaliException e) {
23519       {
23520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23521       };
23522     } catch (...) {
23523       {
23524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23525       };
23526     }
23527   }
23528
23529   jresult = (unsigned long)result;
23530   return jresult;
23531 }
23532
23533
23534 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23535   unsigned int jresult ;
23536   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23537   bool result;
23538
23539   arg1 = (Dali::VectorBase *)jarg1;
23540   {
23541     try {
23542       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23543     } catch (std::out_of_range& e) {
23544       {
23545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23546       };
23547     } catch (std::exception& e) {
23548       {
23549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23550       };
23551     } catch (Dali::DaliException e) {
23552       {
23553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23554       };
23555     } catch (...) {
23556       {
23557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23558       };
23559     }
23560   }
23561
23562   jresult = result;
23563   return jresult;
23564 }
23565
23566
23567 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23568   unsigned long jresult ;
23569   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23570   Dali::VectorBase::SizeType result;
23571
23572   arg1 = (Dali::VectorBase *)jarg1;
23573   {
23574     try {
23575       result = ((Dali::VectorBase const *)arg1)->Capacity();
23576     } catch (std::out_of_range& e) {
23577       {
23578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23579       };
23580     } catch (std::exception& e) {
23581       {
23582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23583       };
23584     } catch (Dali::DaliException e) {
23585       {
23586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23587       };
23588     } catch (...) {
23589       {
23590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23591       };
23592     }
23593   }
23594
23595   jresult = (unsigned long)result;
23596   return jresult;
23597 }
23598
23599
23600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23601   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23602
23603   arg1 = (Dali::VectorBase *)jarg1;
23604   {
23605     try {
23606       (arg1)->Release();
23607     } catch (std::out_of_range& e) {
23608       {
23609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23610       };
23611     } catch (std::exception& e) {
23612       {
23613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23614       };
23615     } catch (Dali::DaliException e) {
23616       {
23617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23618       };
23619     } catch (...) {
23620       {
23621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23622       };
23623     }
23624   }
23625
23626 }
23627
23628
23629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
23630   void * jresult ;
23631   Dali::Image *result = 0 ;
23632
23633   {
23634     try {
23635       result = (Dali::Image *)new Dali::Image();
23636     } catch (std::out_of_range& e) {
23637       {
23638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23639       };
23640     } catch (std::exception& e) {
23641       {
23642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23643       };
23644     } catch (Dali::DaliException e) {
23645       {
23646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23647       };
23648     } catch (...) {
23649       {
23650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23651       };
23652     }
23653   }
23654
23655   jresult = (void *)result;
23656   return jresult;
23657 }
23658
23659
23660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
23661   Dali::Image *arg1 = (Dali::Image *) 0 ;
23662
23663   arg1 = (Dali::Image *)jarg1;
23664   {
23665     try {
23666       delete arg1;
23667     } catch (std::out_of_range& e) {
23668       {
23669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23670       };
23671     } catch (std::exception& e) {
23672       {
23673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23674       };
23675     } catch (Dali::DaliException e) {
23676       {
23677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23678       };
23679     } catch (...) {
23680       {
23681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23682       };
23683     }
23684   }
23685
23686 }
23687
23688
23689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
23690   void * jresult ;
23691   Dali::Image *arg1 = 0 ;
23692   Dali::Image *result = 0 ;
23693
23694   arg1 = (Dali::Image *)jarg1;
23695   if (!arg1) {
23696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23697     return 0;
23698   }
23699   {
23700     try {
23701       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
23702     } catch (std::out_of_range& e) {
23703       {
23704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23705       };
23706     } catch (std::exception& e) {
23707       {
23708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23709       };
23710     } catch (Dali::DaliException e) {
23711       {
23712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23713       };
23714     } catch (...) {
23715       {
23716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23717       };
23718     }
23719   }
23720
23721   jresult = (void *)result;
23722   return jresult;
23723 }
23724
23725
23726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
23727   void * jresult ;
23728   Dali::Image *arg1 = (Dali::Image *) 0 ;
23729   Dali::Image *arg2 = 0 ;
23730   Dali::Image *result = 0 ;
23731
23732   arg1 = (Dali::Image *)jarg1;
23733   arg2 = (Dali::Image *)jarg2;
23734   if (!arg2) {
23735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23736     return 0;
23737   }
23738   {
23739     try {
23740       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
23741     } catch (std::out_of_range& e) {
23742       {
23743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23744       };
23745     } catch (std::exception& e) {
23746       {
23747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23748       };
23749     } catch (Dali::DaliException e) {
23750       {
23751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23752       };
23753     } catch (...) {
23754       {
23755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23756       };
23757     }
23758   }
23759
23760   jresult = (void *)result;
23761   return jresult;
23762 }
23763
23764
23765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
23766   void * jresult ;
23767   Dali::BaseHandle arg1 ;
23768   Dali::BaseHandle *argp1 ;
23769   Dali::Image result;
23770
23771   argp1 = (Dali::BaseHandle *)jarg1;
23772   if (!argp1) {
23773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23774     return 0;
23775   }
23776   arg1 = *argp1;
23777   {
23778     try {
23779       result = Dali::Image::DownCast(arg1);
23780     } catch (std::out_of_range& e) {
23781       {
23782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23783       };
23784     } catch (std::exception& e) {
23785       {
23786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23787       };
23788     } catch (Dali::DaliException e) {
23789       {
23790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23791       };
23792     } catch (...) {
23793       {
23794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23795       };
23796     }
23797   }
23798
23799   jresult = new Dali::Image((const Dali::Image &)result);
23800   return jresult;
23801 }
23802
23803
23804 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
23805   unsigned int jresult ;
23806   Dali::Image *arg1 = (Dali::Image *) 0 ;
23807   unsigned int result;
23808
23809   arg1 = (Dali::Image *)jarg1;
23810   {
23811     try {
23812       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
23813     } catch (std::out_of_range& e) {
23814       {
23815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23816       };
23817     } catch (std::exception& e) {
23818       {
23819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23820       };
23821     } catch (Dali::DaliException e) {
23822       {
23823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23824       };
23825     } catch (...) {
23826       {
23827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23828       };
23829     }
23830   }
23831
23832   jresult = result;
23833   return jresult;
23834 }
23835
23836
23837 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
23838   unsigned int jresult ;
23839   Dali::Image *arg1 = (Dali::Image *) 0 ;
23840   unsigned int result;
23841
23842   arg1 = (Dali::Image *)jarg1;
23843   {
23844     try {
23845       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
23846     } catch (std::out_of_range& e) {
23847       {
23848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23849       };
23850     } catch (std::exception& e) {
23851       {
23852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23853       };
23854     } catch (Dali::DaliException e) {
23855       {
23856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23857       };
23858     } catch (...) {
23859       {
23860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23861       };
23862     }
23863   }
23864
23865   jresult = result;
23866   return jresult;
23867 }
23868
23869
23870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
23871   void * jresult ;
23872   Dali::Image *arg1 = (Dali::Image *) 0 ;
23873   Dali::Image::ImageSignalType *result = 0 ;
23874
23875   arg1 = (Dali::Image *)jarg1;
23876   {
23877     try {
23878       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
23879     } catch (std::out_of_range& e) {
23880       {
23881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23882       };
23883     } catch (std::exception& e) {
23884       {
23885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23886       };
23887     } catch (Dali::DaliException e) {
23888       {
23889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23890       };
23891     } catch (...) {
23892       {
23893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23894       };
23895     }
23896   }
23897
23898   jresult = (void *)result;
23899   return jresult;
23900 }
23901
23902
23903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23904   int jresult ;
23905   Dali::Pixel::Format result;
23906
23907   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23908   jresult = (int)result;
23909   return jresult;
23910 }
23911
23912
23913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23914   int jresult ;
23915   Dali::Pixel::Format result;
23916
23917   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23918   jresult = (int)result;
23919   return jresult;
23920 }
23921
23922
23923 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23924   unsigned int jresult ;
23925   Dali::Pixel::Format arg1 ;
23926   bool result;
23927
23928   arg1 = (Dali::Pixel::Format)jarg1;
23929   {
23930     try {
23931       result = (bool)Dali::Pixel::HasAlpha(arg1);
23932     } catch (std::out_of_range& e) {
23933       {
23934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23935       };
23936     } catch (std::exception& e) {
23937       {
23938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23939       };
23940     } catch (Dali::DaliException e) {
23941       {
23942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23943       };
23944     } catch (...) {
23945       {
23946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23947       };
23948     }
23949   }
23950
23951   jresult = result;
23952   return jresult;
23953 }
23954
23955
23956 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23957   unsigned int jresult ;
23958   Dali::Pixel::Format arg1 ;
23959   unsigned int result;
23960
23961   arg1 = (Dali::Pixel::Format)jarg1;
23962   {
23963     try {
23964       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23965     } catch (std::out_of_range& e) {
23966       {
23967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23968       };
23969     } catch (std::exception& e) {
23970       {
23971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23972       };
23973     } catch (Dali::DaliException e) {
23974       {
23975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23976       };
23977     } catch (...) {
23978       {
23979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23980       };
23981     }
23982   }
23983
23984   jresult = result;
23985   return jresult;
23986 }
23987
23988
23989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23990   Dali::Pixel::Format arg1 ;
23991   int *arg2 = 0 ;
23992   int *arg3 = 0 ;
23993
23994   arg1 = (Dali::Pixel::Format)jarg1;
23995   arg2 = (int *)jarg2;
23996   if (!arg2) {
23997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23998     return ;
23999   }
24000   arg3 = (int *)jarg3;
24001   if (!arg3) {
24002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
24003     return ;
24004   }
24005   {
24006     try {
24007       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
24008     } catch (std::out_of_range& e) {
24009       {
24010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24011       };
24012     } catch (std::exception& e) {
24013       {
24014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24015       };
24016     } catch (Dali::DaliException e) {
24017       {
24018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24019       };
24020     } catch (...) {
24021       {
24022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24023       };
24024     }
24025   }
24026
24027 }
24028
24029
24030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
24031   void * jresult ;
24032   unsigned char *arg1 = (unsigned char *) 0 ;
24033   unsigned int arg2 ;
24034   unsigned int arg3 ;
24035   unsigned int arg4 ;
24036   Dali::Pixel::Format arg5 ;
24037   Dali::PixelData::ReleaseFunction arg6 ;
24038   Dali::PixelData result;
24039
24040   arg1 = jarg1;
24041   arg2 = (unsigned int)jarg2;
24042   arg3 = (unsigned int)jarg3;
24043   arg4 = (unsigned int)jarg4;
24044   arg5 = (Dali::Pixel::Format)jarg5;
24045   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
24046   {
24047     try {
24048       auto pixelBuffer = new unsigned char[jarg2];
24049       memcpy( pixelBuffer, arg1, arg2);
24050       result = Dali::PixelData::New(pixelBuffer,arg2,arg3,arg4,arg5,arg6);
24051     } catch (std::out_of_range& e) {
24052       {
24053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24054       };
24055     } catch (std::exception& e) {
24056       {
24057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24058       };
24059     } catch (Dali::DaliException e) {
24060       {
24061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24062       };
24063     } catch (...) {
24064       {
24065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24066       };
24067     }
24068   }
24069
24070   jresult = new Dali::PixelData((const Dali::PixelData &)result);
24071
24072
24073   return jresult;
24074 }
24075
24076
24077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
24078   void * jresult ;
24079   Dali::PixelData *result = 0 ;
24080
24081   {
24082     try {
24083       result = (Dali::PixelData *)new Dali::PixelData();
24084     } catch (std::out_of_range& e) {
24085       {
24086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24087       };
24088     } catch (std::exception& e) {
24089       {
24090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24091       };
24092     } catch (Dali::DaliException e) {
24093       {
24094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24095       };
24096     } catch (...) {
24097       {
24098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24099       };
24100     }
24101   }
24102
24103   jresult = (void *)result;
24104   return jresult;
24105 }
24106
24107
24108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
24109   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24110
24111   arg1 = (Dali::PixelData *)jarg1;
24112   {
24113     try {
24114       delete arg1;
24115     } catch (std::out_of_range& e) {
24116       {
24117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24118       };
24119     } catch (std::exception& e) {
24120       {
24121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24122       };
24123     } catch (Dali::DaliException e) {
24124       {
24125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24126       };
24127     } catch (...) {
24128       {
24129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24130       };
24131     }
24132   }
24133
24134 }
24135
24136
24137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
24138   void * jresult ;
24139   Dali::PixelData *arg1 = 0 ;
24140   Dali::PixelData *result = 0 ;
24141
24142   arg1 = (Dali::PixelData *)jarg1;
24143   if (!arg1) {
24144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24145     return 0;
24146   }
24147   {
24148     try {
24149       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
24150     } catch (std::out_of_range& e) {
24151       {
24152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24153       };
24154     } catch (std::exception& e) {
24155       {
24156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24157       };
24158     } catch (Dali::DaliException e) {
24159       {
24160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24161       };
24162     } catch (...) {
24163       {
24164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24165       };
24166     }
24167   }
24168
24169   jresult = (void *)result;
24170   return jresult;
24171 }
24172
24173
24174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
24175   void * jresult ;
24176   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24177   Dali::PixelData *arg2 = 0 ;
24178   Dali::PixelData *result = 0 ;
24179
24180   arg1 = (Dali::PixelData *)jarg1;
24181   arg2 = (Dali::PixelData *)jarg2;
24182   if (!arg2) {
24183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24184     return 0;
24185   }
24186   {
24187     try {
24188       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
24189     } catch (std::out_of_range& e) {
24190       {
24191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24192       };
24193     } catch (std::exception& e) {
24194       {
24195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24196       };
24197     } catch (Dali::DaliException e) {
24198       {
24199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24200       };
24201     } catch (...) {
24202       {
24203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24204       };
24205     }
24206   }
24207
24208   jresult = (void *)result;
24209   return jresult;
24210 }
24211
24212
24213 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
24214   unsigned int jresult ;
24215   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24216   unsigned int result;
24217
24218   arg1 = (Dali::PixelData *)jarg1;
24219   {
24220     try {
24221       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
24222     } catch (std::out_of_range& e) {
24223       {
24224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24225       };
24226     } catch (std::exception& e) {
24227       {
24228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24229       };
24230     } catch (Dali::DaliException e) {
24231       {
24232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24233       };
24234     } catch (...) {
24235       {
24236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24237       };
24238     }
24239   }
24240
24241   jresult = result;
24242   return jresult;
24243 }
24244
24245
24246 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
24247   unsigned int jresult ;
24248   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24249   unsigned int result;
24250
24251   arg1 = (Dali::PixelData *)jarg1;
24252   {
24253     try {
24254       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
24255     } catch (std::out_of_range& e) {
24256       {
24257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24258       };
24259     } catch (std::exception& e) {
24260       {
24261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24262       };
24263     } catch (Dali::DaliException e) {
24264       {
24265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24266       };
24267     } catch (...) {
24268       {
24269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24270       };
24271     }
24272   }
24273
24274   jresult = result;
24275   return jresult;
24276 }
24277
24278
24279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
24280   int jresult ;
24281   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24282   Dali::Pixel::Format result;
24283
24284   arg1 = (Dali::PixelData *)jarg1;
24285   {
24286     try {
24287       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
24288     } catch (std::out_of_range& e) {
24289       {
24290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24291       };
24292     } catch (std::exception& e) {
24293       {
24294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24295       };
24296     } catch (Dali::DaliException e) {
24297       {
24298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24299       };
24300     } catch (...) {
24301       {
24302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24303       };
24304     }
24305   }
24306
24307   jresult = (int)result;
24308   return jresult;
24309 }
24310
24311
24312 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24313   unsigned int jresult ;
24314   unsigned int result;
24315
24316   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24317   jresult = result;
24318   return jresult;
24319 }
24320
24321
24322 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24323   unsigned int jresult ;
24324   unsigned int result;
24325
24326   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24327   jresult = result;
24328   return jresult;
24329 }
24330
24331
24332 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24333   unsigned int jresult ;
24334   unsigned int result;
24335
24336   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24337   jresult = result;
24338   return jresult;
24339 }
24340
24341
24342 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24343   unsigned int jresult ;
24344   unsigned int result;
24345
24346   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24347   jresult = result;
24348   return jresult;
24349 }
24350
24351
24352 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24353   unsigned int jresult ;
24354   unsigned int result;
24355
24356   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24357   jresult = result;
24358   return jresult;
24359 }
24360
24361
24362 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24363   unsigned int jresult ;
24364   unsigned int result;
24365
24366   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24367   jresult = result;
24368   return jresult;
24369 }
24370
24371
24372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24373   void * jresult ;
24374   Dali::TextureType::Type arg1 ;
24375   Dali::Pixel::Format arg2 ;
24376   unsigned int arg3 ;
24377   unsigned int arg4 ;
24378   Dali::Texture result;
24379
24380   arg1 = (Dali::TextureType::Type)jarg1;
24381   arg2 = (Dali::Pixel::Format)jarg2;
24382   arg3 = (unsigned int)jarg3;
24383   arg4 = (unsigned int)jarg4;
24384   {
24385     try {
24386       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24387     } catch (std::out_of_range& e) {
24388       {
24389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24390       };
24391     } catch (std::exception& e) {
24392       {
24393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24394       };
24395     } catch (Dali::DaliException e) {
24396       {
24397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24398       };
24399     } catch (...) {
24400       {
24401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24402       };
24403     }
24404   }
24405
24406   jresult = new Dali::Texture((const Dali::Texture &)result);
24407   return jresult;
24408 }
24409
24410
24411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24412   void * jresult ;
24413   NativeImageInterface *arg1 = 0 ;
24414   Dali::Texture result;
24415
24416   arg1 = (NativeImageInterface *)jarg1;
24417   if (!arg1) {
24418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24419     return 0;
24420   }
24421   {
24422     try {
24423       result = Dali::Texture::New(*arg1);
24424     } catch (std::out_of_range& e) {
24425       {
24426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24427       };
24428     } catch (std::exception& e) {
24429       {
24430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24431       };
24432     } catch (Dali::DaliException e) {
24433       {
24434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24435       };
24436     } catch (...) {
24437       {
24438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24439       };
24440     }
24441   }
24442
24443   jresult = new Dali::Texture((const Dali::Texture &)result);
24444   return jresult;
24445 }
24446
24447
24448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24449   void * jresult ;
24450   Dali::Texture *result = 0 ;
24451
24452   {
24453     try {
24454       result = (Dali::Texture *)new Dali::Texture();
24455     } catch (std::out_of_range& e) {
24456       {
24457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24458       };
24459     } catch (std::exception& e) {
24460       {
24461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24462       };
24463     } catch (Dali::DaliException e) {
24464       {
24465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24466       };
24467     } catch (...) {
24468       {
24469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24470       };
24471     }
24472   }
24473
24474   jresult = (void *)result;
24475   return jresult;
24476 }
24477
24478
24479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24480   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24481
24482   arg1 = (Dali::Texture *)jarg1;
24483   {
24484     try {
24485       delete arg1;
24486     } catch (std::out_of_range& e) {
24487       {
24488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24489       };
24490     } catch (std::exception& e) {
24491       {
24492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24493       };
24494     } catch (Dali::DaliException e) {
24495       {
24496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24497       };
24498     } catch (...) {
24499       {
24500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24501       };
24502     }
24503   }
24504
24505 }
24506
24507
24508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24509   void * jresult ;
24510   Dali::Texture *arg1 = 0 ;
24511   Dali::Texture *result = 0 ;
24512
24513   arg1 = (Dali::Texture *)jarg1;
24514   if (!arg1) {
24515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24516     return 0;
24517   }
24518   {
24519     try {
24520       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24521     } catch (std::out_of_range& e) {
24522       {
24523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24524       };
24525     } catch (std::exception& e) {
24526       {
24527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24528       };
24529     } catch (Dali::DaliException e) {
24530       {
24531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24532       };
24533     } catch (...) {
24534       {
24535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24536       };
24537     }
24538   }
24539
24540   jresult = (void *)result;
24541   return jresult;
24542 }
24543
24544
24545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24546   void * jresult ;
24547   Dali::BaseHandle arg1 ;
24548   Dali::BaseHandle *argp1 ;
24549   Dali::Texture result;
24550
24551   argp1 = (Dali::BaseHandle *)jarg1;
24552   if (!argp1) {
24553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24554     return 0;
24555   }
24556   arg1 = *argp1;
24557   {
24558     try {
24559       result = Dali::Texture::DownCast(arg1);
24560     } catch (std::out_of_range& e) {
24561       {
24562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24563       };
24564     } catch (std::exception& e) {
24565       {
24566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24567       };
24568     } catch (Dali::DaliException e) {
24569       {
24570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24571       };
24572     } catch (...) {
24573       {
24574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24575       };
24576     }
24577   }
24578
24579   jresult = new Dali::Texture((const Dali::Texture &)result);
24580   return jresult;
24581 }
24582
24583
24584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24585   void * jresult ;
24586   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24587   Dali::Texture *arg2 = 0 ;
24588   Dali::Texture *result = 0 ;
24589
24590   arg1 = (Dali::Texture *)jarg1;
24591   arg2 = (Dali::Texture *)jarg2;
24592   if (!arg2) {
24593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24594     return 0;
24595   }
24596   {
24597     try {
24598       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24599     } catch (std::out_of_range& e) {
24600       {
24601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24602       };
24603     } catch (std::exception& e) {
24604       {
24605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24606       };
24607     } catch (Dali::DaliException e) {
24608       {
24609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24610       };
24611     } catch (...) {
24612       {
24613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24614       };
24615     }
24616   }
24617
24618   jresult = (void *)result;
24619   return jresult;
24620 }
24621
24622
24623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24624   unsigned int jresult ;
24625   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24626   Dali::PixelData arg2 ;
24627   Dali::PixelData *argp2 ;
24628   bool result;
24629
24630   arg1 = (Dali::Texture *)jarg1;
24631   argp2 = (Dali::PixelData *)jarg2;
24632   if (!argp2) {
24633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24634     return 0;
24635   }
24636   arg2 = *argp2;
24637   {
24638     try {
24639       result = (bool)(arg1)->Upload(arg2);
24640     } catch (std::out_of_range& e) {
24641       {
24642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24643       };
24644     } catch (std::exception& e) {
24645       {
24646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24647       };
24648     } catch (Dali::DaliException e) {
24649       {
24650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24651       };
24652     } catch (...) {
24653       {
24654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24655       };
24656     }
24657   }
24658
24659   jresult = result;
24660   return jresult;
24661 }
24662
24663
24664 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) {
24665   unsigned int jresult ;
24666   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24667   Dali::PixelData arg2 ;
24668   unsigned int arg3 ;
24669   unsigned int arg4 ;
24670   unsigned int arg5 ;
24671   unsigned int arg6 ;
24672   unsigned int arg7 ;
24673   unsigned int arg8 ;
24674   Dali::PixelData *argp2 ;
24675   bool result;
24676
24677   arg1 = (Dali::Texture *)jarg1;
24678   argp2 = (Dali::PixelData *)jarg2;
24679   if (!argp2) {
24680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24681     return 0;
24682   }
24683   arg2 = *argp2;
24684   arg3 = (unsigned int)jarg3;
24685   arg4 = (unsigned int)jarg4;
24686   arg5 = (unsigned int)jarg5;
24687   arg6 = (unsigned int)jarg6;
24688   arg7 = (unsigned int)jarg7;
24689   arg8 = (unsigned int)jarg8;
24690   {
24691     try {
24692       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24693     } catch (std::out_of_range& e) {
24694       {
24695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24696       };
24697     } catch (std::exception& e) {
24698       {
24699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24700       };
24701     } catch (Dali::DaliException e) {
24702       {
24703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24704       };
24705     } catch (...) {
24706       {
24707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24708       };
24709     }
24710   }
24711
24712   jresult = result;
24713   return jresult;
24714 }
24715
24716
24717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24718   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24719
24720   arg1 = (Dali::Texture *)jarg1;
24721   {
24722     try {
24723       (arg1)->GenerateMipmaps();
24724     } catch (std::out_of_range& e) {
24725       {
24726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24727       };
24728     } catch (std::exception& e) {
24729       {
24730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24731       };
24732     } catch (Dali::DaliException e) {
24733       {
24734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24735       };
24736     } catch (...) {
24737       {
24738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24739       };
24740     }
24741   }
24742
24743 }
24744
24745
24746 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24747   unsigned int jresult ;
24748   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24749   unsigned int result;
24750
24751   arg1 = (Dali::Texture *)jarg1;
24752   {
24753     try {
24754       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24755     } catch (std::out_of_range& e) {
24756       {
24757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24758       };
24759     } catch (std::exception& e) {
24760       {
24761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24762       };
24763     } catch (Dali::DaliException e) {
24764       {
24765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24766       };
24767     } catch (...) {
24768       {
24769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24770       };
24771     }
24772   }
24773
24774   jresult = result;
24775   return jresult;
24776 }
24777
24778
24779 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24780   unsigned int jresult ;
24781   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24782   unsigned int result;
24783
24784   arg1 = (Dali::Texture *)jarg1;
24785   {
24786     try {
24787       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24788     } catch (std::out_of_range& e) {
24789       {
24790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24791       };
24792     } catch (std::exception& e) {
24793       {
24794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24795       };
24796     } catch (Dali::DaliException e) {
24797       {
24798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24799       };
24800     } catch (...) {
24801       {
24802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24803       };
24804     }
24805   }
24806
24807   jresult = result;
24808   return jresult;
24809 }
24810
24811
24812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24813   void * jresult ;
24814   Dali::Sampler result;
24815
24816   {
24817     try {
24818       result = Dali::Sampler::New();
24819     } catch (std::out_of_range& e) {
24820       {
24821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24822       };
24823     } catch (std::exception& e) {
24824       {
24825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24826       };
24827     } catch (Dali::DaliException e) {
24828       {
24829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24830       };
24831     } catch (...) {
24832       {
24833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24834       };
24835     }
24836   }
24837
24838   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24839   return jresult;
24840 }
24841
24842
24843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24844   void * jresult ;
24845   Dali::Sampler *result = 0 ;
24846
24847   {
24848     try {
24849       result = (Dali::Sampler *)new Dali::Sampler();
24850     } catch (std::out_of_range& e) {
24851       {
24852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24853       };
24854     } catch (std::exception& e) {
24855       {
24856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24857       };
24858     } catch (Dali::DaliException e) {
24859       {
24860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24861       };
24862     } catch (...) {
24863       {
24864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24865       };
24866     }
24867   }
24868
24869   jresult = (void *)result;
24870   return jresult;
24871 }
24872
24873
24874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24875   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24876
24877   arg1 = (Dali::Sampler *)jarg1;
24878   {
24879     try {
24880       delete arg1;
24881     } catch (std::out_of_range& e) {
24882       {
24883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24884       };
24885     } catch (std::exception& e) {
24886       {
24887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24888       };
24889     } catch (Dali::DaliException e) {
24890       {
24891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24892       };
24893     } catch (...) {
24894       {
24895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24896       };
24897     }
24898   }
24899
24900 }
24901
24902
24903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24904   void * jresult ;
24905   Dali::Sampler *arg1 = 0 ;
24906   Dali::Sampler *result = 0 ;
24907
24908   arg1 = (Dali::Sampler *)jarg1;
24909   if (!arg1) {
24910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24911     return 0;
24912   }
24913   {
24914     try {
24915       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24916     } catch (std::out_of_range& e) {
24917       {
24918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24919       };
24920     } catch (std::exception& e) {
24921       {
24922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24923       };
24924     } catch (Dali::DaliException e) {
24925       {
24926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24927       };
24928     } catch (...) {
24929       {
24930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24931       };
24932     }
24933   }
24934
24935   jresult = (void *)result;
24936   return jresult;
24937 }
24938
24939
24940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24941   void * jresult ;
24942   Dali::BaseHandle arg1 ;
24943   Dali::BaseHandle *argp1 ;
24944   Dali::Sampler result;
24945
24946   argp1 = (Dali::BaseHandle *)jarg1;
24947   if (!argp1) {
24948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24949     return 0;
24950   }
24951   arg1 = *argp1;
24952   {
24953     try {
24954       result = Dali::Sampler::DownCast(arg1);
24955     } catch (std::out_of_range& e) {
24956       {
24957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24958       };
24959     } catch (std::exception& e) {
24960       {
24961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24962       };
24963     } catch (Dali::DaliException e) {
24964       {
24965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24966       };
24967     } catch (...) {
24968       {
24969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24970       };
24971     }
24972   }
24973
24974   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24975   return jresult;
24976 }
24977
24978
24979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24980   void * jresult ;
24981   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24982   Dali::Sampler *arg2 = 0 ;
24983   Dali::Sampler *result = 0 ;
24984
24985   arg1 = (Dali::Sampler *)jarg1;
24986   arg2 = (Dali::Sampler *)jarg2;
24987   if (!arg2) {
24988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24989     return 0;
24990   }
24991   {
24992     try {
24993       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24994     } catch (std::out_of_range& e) {
24995       {
24996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24997       };
24998     } catch (std::exception& e) {
24999       {
25000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25001       };
25002     } catch (Dali::DaliException e) {
25003       {
25004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25005       };
25006     } catch (...) {
25007       {
25008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25009       };
25010     }
25011   }
25012
25013   jresult = (void *)result;
25014   return jresult;
25015 }
25016
25017
25018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
25019   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25020   Dali::FilterMode::Type arg2 ;
25021   Dali::FilterMode::Type arg3 ;
25022
25023   arg1 = (Dali::Sampler *)jarg1;
25024   arg2 = (Dali::FilterMode::Type)jarg2;
25025   arg3 = (Dali::FilterMode::Type)jarg3;
25026   {
25027     try {
25028       (arg1)->SetFilterMode(arg2,arg3);
25029     } catch (std::out_of_range& e) {
25030       {
25031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25032       };
25033     } catch (std::exception& e) {
25034       {
25035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25036       };
25037     } catch (Dali::DaliException e) {
25038       {
25039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25040       };
25041     } catch (...) {
25042       {
25043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25044       };
25045     }
25046   }
25047
25048 }
25049
25050
25051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
25052   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25053   Dali::WrapMode::Type arg2 ;
25054   Dali::WrapMode::Type arg3 ;
25055
25056   arg1 = (Dali::Sampler *)jarg1;
25057   arg2 = (Dali::WrapMode::Type)jarg2;
25058   arg3 = (Dali::WrapMode::Type)jarg3;
25059   {
25060     try {
25061       (arg1)->SetWrapMode(arg2,arg3);
25062     } catch (std::out_of_range& e) {
25063       {
25064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25065       };
25066     } catch (std::exception& e) {
25067       {
25068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25069       };
25070     } catch (Dali::DaliException e) {
25071       {
25072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25073       };
25074     } catch (...) {
25075       {
25076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25077       };
25078     }
25079   }
25080
25081 }
25082
25083
25084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
25085   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25086   Dali::WrapMode::Type arg2 ;
25087   Dali::WrapMode::Type arg3 ;
25088   Dali::WrapMode::Type arg4 ;
25089
25090   arg1 = (Dali::Sampler *)jarg1;
25091   arg2 = (Dali::WrapMode::Type)jarg2;
25092   arg3 = (Dali::WrapMode::Type)jarg3;
25093   arg4 = (Dali::WrapMode::Type)jarg4;
25094   {
25095     try {
25096       (arg1)->SetWrapMode(arg2,arg3,arg4);
25097     } catch (std::out_of_range& e) {
25098       {
25099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25100       };
25101     } catch (std::exception& e) {
25102       {
25103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25104       };
25105     } catch (Dali::DaliException e) {
25106       {
25107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25108       };
25109     } catch (...) {
25110       {
25111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25112       };
25113     }
25114   }
25115
25116 }
25117
25118
25119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
25120   void * jresult ;
25121   Dali::TextureSet result;
25122
25123   {
25124     try {
25125       result = Dali::TextureSet::New();
25126     } catch (std::out_of_range& e) {
25127       {
25128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25129       };
25130     } catch (std::exception& e) {
25131       {
25132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25133       };
25134     } catch (Dali::DaliException e) {
25135       {
25136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25137       };
25138     } catch (...) {
25139       {
25140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25141       };
25142     }
25143   }
25144
25145   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25146   return jresult;
25147 }
25148
25149
25150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
25151   void * jresult ;
25152   Dali::TextureSet *result = 0 ;
25153
25154   {
25155     try {
25156       result = (Dali::TextureSet *)new Dali::TextureSet();
25157     } catch (std::out_of_range& e) {
25158       {
25159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25160       };
25161     } catch (std::exception& e) {
25162       {
25163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25164       };
25165     } catch (Dali::DaliException e) {
25166       {
25167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25168       };
25169     } catch (...) {
25170       {
25171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25172       };
25173     }
25174   }
25175
25176   jresult = (void *)result;
25177   return jresult;
25178 }
25179
25180
25181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
25182   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25183
25184   arg1 = (Dali::TextureSet *)jarg1;
25185   {
25186     try {
25187       delete arg1;
25188     } catch (std::out_of_range& e) {
25189       {
25190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25191       };
25192     } catch (std::exception& e) {
25193       {
25194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25195       };
25196     } catch (Dali::DaliException e) {
25197       {
25198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25199       };
25200     } catch (...) {
25201       {
25202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25203       };
25204     }
25205   }
25206
25207 }
25208
25209
25210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
25211   void * jresult ;
25212   Dali::TextureSet *arg1 = 0 ;
25213   Dali::TextureSet *result = 0 ;
25214
25215   arg1 = (Dali::TextureSet *)jarg1;
25216   if (!arg1) {
25217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25218     return 0;
25219   }
25220   {
25221     try {
25222       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
25223     } catch (std::out_of_range& e) {
25224       {
25225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25226       };
25227     } catch (std::exception& e) {
25228       {
25229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25230       };
25231     } catch (Dali::DaliException e) {
25232       {
25233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25234       };
25235     } catch (...) {
25236       {
25237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25238       };
25239     }
25240   }
25241
25242   jresult = (void *)result;
25243   return jresult;
25244 }
25245
25246
25247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
25248   void * jresult ;
25249   Dali::BaseHandle arg1 ;
25250   Dali::BaseHandle *argp1 ;
25251   Dali::TextureSet result;
25252
25253   argp1 = (Dali::BaseHandle *)jarg1;
25254   if (!argp1) {
25255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25256     return 0;
25257   }
25258   arg1 = *argp1;
25259   {
25260     try {
25261       result = Dali::TextureSet::DownCast(arg1);
25262     } catch (std::out_of_range& e) {
25263       {
25264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25265       };
25266     } catch (std::exception& e) {
25267       {
25268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25269       };
25270     } catch (Dali::DaliException e) {
25271       {
25272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25273       };
25274     } catch (...) {
25275       {
25276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25277       };
25278     }
25279   }
25280
25281   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25282   return jresult;
25283 }
25284
25285
25286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
25287   void * jresult ;
25288   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25289   Dali::TextureSet *arg2 = 0 ;
25290   Dali::TextureSet *result = 0 ;
25291
25292   arg1 = (Dali::TextureSet *)jarg1;
25293   arg2 = (Dali::TextureSet *)jarg2;
25294   if (!arg2) {
25295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25296     return 0;
25297   }
25298   {
25299     try {
25300       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
25301     } catch (std::out_of_range& e) {
25302       {
25303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25304       };
25305     } catch (std::exception& e) {
25306       {
25307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25308       };
25309     } catch (Dali::DaliException e) {
25310       {
25311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25312       };
25313     } catch (...) {
25314       {
25315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25316       };
25317     }
25318   }
25319
25320   jresult = (void *)result;
25321   return jresult;
25322 }
25323
25324
25325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25326   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25327   size_t arg2 ;
25328   Dali::Texture arg3 ;
25329   Dali::Texture *argp3 ;
25330
25331   arg1 = (Dali::TextureSet *)jarg1;
25332   arg2 = (size_t)jarg2;
25333   argp3 = (Dali::Texture *)jarg3;
25334   if (!argp3) {
25335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25336     return ;
25337   }
25338   arg3 = *argp3;
25339   {
25340     try {
25341       (arg1)->SetTexture(arg2,arg3);
25342     } catch (std::out_of_range& e) {
25343       {
25344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25345       };
25346     } catch (std::exception& e) {
25347       {
25348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25349       };
25350     } catch (Dali::DaliException e) {
25351       {
25352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25353       };
25354     } catch (...) {
25355       {
25356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25357       };
25358     }
25359   }
25360
25361 }
25362
25363
25364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25365   void * jresult ;
25366   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25367   size_t arg2 ;
25368   Dali::Texture result;
25369
25370   arg1 = (Dali::TextureSet *)jarg1;
25371   arg2 = (size_t)jarg2;
25372   {
25373     try {
25374       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25375     } catch (std::out_of_range& e) {
25376       {
25377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25378       };
25379     } catch (std::exception& e) {
25380       {
25381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25382       };
25383     } catch (Dali::DaliException e) {
25384       {
25385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25386       };
25387     } catch (...) {
25388       {
25389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25390       };
25391     }
25392   }
25393
25394   jresult = new Dali::Texture((const Dali::Texture &)result);
25395   return jresult;
25396 }
25397
25398
25399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25400   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25401   size_t arg2 ;
25402   Dali::Sampler arg3 ;
25403   Dali::Sampler *argp3 ;
25404
25405   arg1 = (Dali::TextureSet *)jarg1;
25406   arg2 = (size_t)jarg2;
25407   argp3 = (Dali::Sampler *)jarg3;
25408   if (!argp3) {
25409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25410     return ;
25411   }
25412   arg3 = *argp3;
25413   {
25414     try {
25415       (arg1)->SetSampler(arg2,arg3);
25416     } catch (std::out_of_range& e) {
25417       {
25418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25419       };
25420     } catch (std::exception& e) {
25421       {
25422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25423       };
25424     } catch (Dali::DaliException e) {
25425       {
25426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25427       };
25428     } catch (...) {
25429       {
25430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25431       };
25432     }
25433   }
25434
25435 }
25436
25437
25438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25439   void * jresult ;
25440   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25441   size_t arg2 ;
25442   Dali::Sampler result;
25443
25444   arg1 = (Dali::TextureSet *)jarg1;
25445   arg2 = (size_t)jarg2;
25446   {
25447     try {
25448       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25449     } catch (std::out_of_range& e) {
25450       {
25451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25452       };
25453     } catch (std::exception& e) {
25454       {
25455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25456       };
25457     } catch (Dali::DaliException e) {
25458       {
25459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25460       };
25461     } catch (...) {
25462       {
25463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25464       };
25465     }
25466   }
25467
25468   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25469   return jresult;
25470 }
25471
25472
25473 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25474   unsigned long jresult ;
25475   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25476   size_t result;
25477
25478   arg1 = (Dali::TextureSet *)jarg1;
25479   {
25480     try {
25481       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25482     } catch (std::out_of_range& e) {
25483       {
25484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25485       };
25486     } catch (std::exception& e) {
25487       {
25488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25489       };
25490     } catch (Dali::DaliException e) {
25491       {
25492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25493       };
25494     } catch (...) {
25495       {
25496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25497       };
25498     }
25499   }
25500
25501   jresult = (unsigned long)result;
25502   return jresult;
25503 }
25504
25505
25506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25507   void * jresult ;
25508   Dali::Property::Map *arg1 = 0 ;
25509   Dali::PropertyBuffer result;
25510
25511   arg1 = (Dali::Property::Map *)jarg1;
25512   if (!arg1) {
25513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25514     return 0;
25515   }
25516   {
25517     try {
25518       result = Dali::PropertyBuffer::New(*arg1);
25519     } catch (std::out_of_range& e) {
25520       {
25521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25522       };
25523     } catch (std::exception& e) {
25524       {
25525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25526       };
25527     } catch (Dali::DaliException e) {
25528       {
25529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25530       };
25531     } catch (...) {
25532       {
25533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25534       };
25535     }
25536   }
25537
25538   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25539   return jresult;
25540 }
25541
25542
25543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25544   void * jresult ;
25545   Dali::PropertyBuffer *result = 0 ;
25546
25547   {
25548     try {
25549       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25550     } catch (std::out_of_range& e) {
25551       {
25552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25553       };
25554     } catch (std::exception& e) {
25555       {
25556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25557       };
25558     } catch (Dali::DaliException e) {
25559       {
25560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25561       };
25562     } catch (...) {
25563       {
25564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25565       };
25566     }
25567   }
25568
25569   jresult = (void *)result;
25570   return jresult;
25571 }
25572
25573
25574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25575   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25576
25577   arg1 = (Dali::PropertyBuffer *)jarg1;
25578   {
25579     try {
25580       delete arg1;
25581     } catch (std::out_of_range& e) {
25582       {
25583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25584       };
25585     } catch (std::exception& e) {
25586       {
25587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25588       };
25589     } catch (Dali::DaliException e) {
25590       {
25591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25592       };
25593     } catch (...) {
25594       {
25595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25596       };
25597     }
25598   }
25599
25600 }
25601
25602
25603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25604   void * jresult ;
25605   Dali::PropertyBuffer *arg1 = 0 ;
25606   Dali::PropertyBuffer *result = 0 ;
25607
25608   arg1 = (Dali::PropertyBuffer *)jarg1;
25609   if (!arg1) {
25610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25611     return 0;
25612   }
25613   {
25614     try {
25615       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25616     } catch (std::out_of_range& e) {
25617       {
25618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25619       };
25620     } catch (std::exception& e) {
25621       {
25622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25623       };
25624     } catch (Dali::DaliException e) {
25625       {
25626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25627       };
25628     } catch (...) {
25629       {
25630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25631       };
25632     }
25633   }
25634
25635   jresult = (void *)result;
25636   return jresult;
25637 }
25638
25639
25640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25641   void * jresult ;
25642   Dali::BaseHandle arg1 ;
25643   Dali::BaseHandle *argp1 ;
25644   Dali::PropertyBuffer result;
25645
25646   argp1 = (Dali::BaseHandle *)jarg1;
25647   if (!argp1) {
25648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25649     return 0;
25650   }
25651   arg1 = *argp1;
25652   {
25653     try {
25654       result = Dali::PropertyBuffer::DownCast(arg1);
25655     } catch (std::out_of_range& e) {
25656       {
25657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25658       };
25659     } catch (std::exception& e) {
25660       {
25661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25662       };
25663     } catch (Dali::DaliException e) {
25664       {
25665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25666       };
25667     } catch (...) {
25668       {
25669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25670       };
25671     }
25672   }
25673
25674   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25675   return jresult;
25676 }
25677
25678
25679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25680   void * jresult ;
25681   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25682   Dali::PropertyBuffer *arg2 = 0 ;
25683   Dali::PropertyBuffer *result = 0 ;
25684
25685   arg1 = (Dali::PropertyBuffer *)jarg1;
25686   arg2 = (Dali::PropertyBuffer *)jarg2;
25687   if (!arg2) {
25688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25689     return 0;
25690   }
25691   {
25692     try {
25693       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25694     } catch (std::out_of_range& e) {
25695       {
25696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25697       };
25698     } catch (std::exception& e) {
25699       {
25700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25701       };
25702     } catch (Dali::DaliException e) {
25703       {
25704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25705       };
25706     } catch (...) {
25707       {
25708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25709       };
25710     }
25711   }
25712
25713   jresult = (void *)result;
25714   return jresult;
25715 }
25716
25717
25718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25719   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25720   void *arg2 = (void *) 0 ;
25721   std::size_t arg3 ;
25722
25723   arg1 = (Dali::PropertyBuffer *)jarg1;
25724   arg2 = jarg2;
25725   arg3 = (std::size_t)jarg3;
25726   {
25727     try {
25728       (arg1)->SetData((void const *)arg2,arg3);
25729     } catch (std::out_of_range& e) {
25730       {
25731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25732       };
25733     } catch (std::exception& e) {
25734       {
25735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25736       };
25737     } catch (Dali::DaliException e) {
25738       {
25739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25740       };
25741     } catch (...) {
25742       {
25743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25744       };
25745     }
25746   }
25747
25748 }
25749
25750
25751 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25752   unsigned long jresult ;
25753   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25754   std::size_t result;
25755
25756   arg1 = (Dali::PropertyBuffer *)jarg1;
25757   {
25758     try {
25759       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25760     } catch (std::out_of_range& e) {
25761       {
25762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25763       };
25764     } catch (std::exception& e) {
25765       {
25766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25767       };
25768     } catch (Dali::DaliException e) {
25769       {
25770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25771       };
25772     } catch (...) {
25773       {
25774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25775       };
25776     }
25777   }
25778
25779   jresult = (unsigned long)result;
25780   return jresult;
25781 }
25782
25783
25784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25785   void * jresult ;
25786   Dali::Geometry result;
25787
25788   {
25789     try {
25790       result = Dali::Geometry::New();
25791     } catch (std::out_of_range& e) {
25792       {
25793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25794       };
25795     } catch (std::exception& e) {
25796       {
25797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25798       };
25799     } catch (Dali::DaliException e) {
25800       {
25801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25802       };
25803     } catch (...) {
25804       {
25805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25806       };
25807     }
25808   }
25809
25810   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25811   return jresult;
25812 }
25813
25814
25815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25816   void * jresult ;
25817   Dali::Geometry *result = 0 ;
25818
25819   {
25820     try {
25821       result = (Dali::Geometry *)new Dali::Geometry();
25822     } catch (std::out_of_range& e) {
25823       {
25824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25825       };
25826     } catch (std::exception& e) {
25827       {
25828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25829       };
25830     } catch (Dali::DaliException e) {
25831       {
25832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25833       };
25834     } catch (...) {
25835       {
25836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25837       };
25838     }
25839   }
25840
25841   jresult = (void *)result;
25842   return jresult;
25843 }
25844
25845
25846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25847   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25848
25849   arg1 = (Dali::Geometry *)jarg1;
25850   {
25851     try {
25852       delete arg1;
25853     } catch (std::out_of_range& e) {
25854       {
25855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25856       };
25857     } catch (std::exception& e) {
25858       {
25859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25860       };
25861     } catch (Dali::DaliException e) {
25862       {
25863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25864       };
25865     } catch (...) {
25866       {
25867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25868       };
25869     }
25870   }
25871
25872 }
25873
25874
25875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25876   void * jresult ;
25877   Dali::Geometry *arg1 = 0 ;
25878   Dali::Geometry *result = 0 ;
25879
25880   arg1 = (Dali::Geometry *)jarg1;
25881   if (!arg1) {
25882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25883     return 0;
25884   }
25885   {
25886     try {
25887       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25888     } catch (std::out_of_range& e) {
25889       {
25890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25891       };
25892     } catch (std::exception& e) {
25893       {
25894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25895       };
25896     } catch (Dali::DaliException e) {
25897       {
25898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25899       };
25900     } catch (...) {
25901       {
25902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25903       };
25904     }
25905   }
25906
25907   jresult = (void *)result;
25908   return jresult;
25909 }
25910
25911
25912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25913   void * jresult ;
25914   Dali::BaseHandle arg1 ;
25915   Dali::BaseHandle *argp1 ;
25916   Dali::Geometry result;
25917
25918   argp1 = (Dali::BaseHandle *)jarg1;
25919   if (!argp1) {
25920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25921     return 0;
25922   }
25923   arg1 = *argp1;
25924   {
25925     try {
25926       result = Dali::Geometry::DownCast(arg1);
25927     } catch (std::out_of_range& e) {
25928       {
25929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25930       };
25931     } catch (std::exception& e) {
25932       {
25933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25934       };
25935     } catch (Dali::DaliException e) {
25936       {
25937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25938       };
25939     } catch (...) {
25940       {
25941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25942       };
25943     }
25944   }
25945
25946   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25947   return jresult;
25948 }
25949
25950
25951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25952   void * jresult ;
25953   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25954   Dali::Geometry *arg2 = 0 ;
25955   Dali::Geometry *result = 0 ;
25956
25957   arg1 = (Dali::Geometry *)jarg1;
25958   arg2 = (Dali::Geometry *)jarg2;
25959   if (!arg2) {
25960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25961     return 0;
25962   }
25963   {
25964     try {
25965       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25966     } catch (std::out_of_range& e) {
25967       {
25968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25969       };
25970     } catch (std::exception& e) {
25971       {
25972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25973       };
25974     } catch (Dali::DaliException e) {
25975       {
25976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25977       };
25978     } catch (...) {
25979       {
25980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25981       };
25982     }
25983   }
25984
25985   jresult = (void *)result;
25986   return jresult;
25987 }
25988
25989
25990 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25991   unsigned long jresult ;
25992   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25993   Dali::PropertyBuffer *arg2 = 0 ;
25994   std::size_t result;
25995
25996   arg1 = (Dali::Geometry *)jarg1;
25997   arg2 = (Dali::PropertyBuffer *)jarg2;
25998   if (!arg2) {
25999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
26000     return 0;
26001   }
26002   {
26003     try {
26004       result = (arg1)->AddVertexBuffer(*arg2);
26005     } catch (std::out_of_range& e) {
26006       {
26007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26008       };
26009     } catch (std::exception& e) {
26010       {
26011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26012       };
26013     } catch (Dali::DaliException e) {
26014       {
26015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26016       };
26017     } catch (...) {
26018       {
26019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26020       };
26021     }
26022   }
26023
26024   jresult = (unsigned long)result;
26025   return jresult;
26026 }
26027
26028
26029 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
26030   unsigned long jresult ;
26031   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26032   std::size_t result;
26033
26034   arg1 = (Dali::Geometry *)jarg1;
26035   {
26036     try {
26037       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
26038     } catch (std::out_of_range& e) {
26039       {
26040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26041       };
26042     } catch (std::exception& e) {
26043       {
26044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26045       };
26046     } catch (Dali::DaliException e) {
26047       {
26048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26049       };
26050     } catch (...) {
26051       {
26052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26053       };
26054     }
26055   }
26056
26057   jresult = (unsigned long)result;
26058   return jresult;
26059 }
26060
26061
26062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
26063   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26064   std::size_t arg2 ;
26065
26066   arg1 = (Dali::Geometry *)jarg1;
26067   arg2 = (std::size_t)jarg2;
26068   {
26069     try {
26070       (arg1)->RemoveVertexBuffer(arg2);
26071     } catch (std::out_of_range& e) {
26072       {
26073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26074       };
26075     } catch (std::exception& e) {
26076       {
26077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26078       };
26079     } catch (Dali::DaliException e) {
26080       {
26081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26082       };
26083     } catch (...) {
26084       {
26085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26086       };
26087     }
26088   }
26089
26090 }
26091
26092
26093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
26094   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26095   unsigned short *arg2 = (unsigned short *) 0 ;
26096   size_t arg3 ;
26097
26098   arg1 = (Dali::Geometry *)jarg1;
26099   arg2 = jarg2;
26100   arg3 = (size_t)jarg3;
26101   {
26102     try {
26103       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
26104     } catch (std::out_of_range& e) {
26105       {
26106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26107       };
26108     } catch (std::exception& e) {
26109       {
26110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26111       };
26112     } catch (Dali::DaliException e) {
26113       {
26114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26115       };
26116     } catch (...) {
26117       {
26118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26119       };
26120     }
26121   }
26122
26123
26124
26125 }
26126
26127
26128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
26129   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26130   Dali::Geometry::Type arg2 ;
26131
26132   arg1 = (Dali::Geometry *)jarg1;
26133   arg2 = (Dali::Geometry::Type)jarg2;
26134   {
26135     try {
26136       (arg1)->SetType(arg2);
26137     } catch (std::out_of_range& e) {
26138       {
26139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26140       };
26141     } catch (std::exception& e) {
26142       {
26143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26144       };
26145     } catch (Dali::DaliException e) {
26146       {
26147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26148       };
26149     } catch (...) {
26150       {
26151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26152       };
26153     }
26154   }
26155
26156 }
26157
26158
26159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
26160   int jresult ;
26161   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26162   Dali::Geometry::Type result;
26163
26164   arg1 = (Dali::Geometry *)jarg1;
26165   {
26166     try {
26167       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
26168     } catch (std::out_of_range& e) {
26169       {
26170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26171       };
26172     } catch (std::exception& e) {
26173       {
26174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26175       };
26176     } catch (Dali::DaliException e) {
26177       {
26178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26179       };
26180     } catch (...) {
26181       {
26182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26183       };
26184     }
26185   }
26186
26187   jresult = (int)result;
26188   return jresult;
26189 }
26190
26191
26192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
26193   void * jresult ;
26194   Dali::Shader::Hint *result = 0 ;
26195
26196   {
26197     try {
26198       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
26199     } catch (std::out_of_range& e) {
26200       {
26201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26202       };
26203     } catch (std::exception& e) {
26204       {
26205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26206       };
26207     } catch (Dali::DaliException e) {
26208       {
26209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26210       };
26211     } catch (...) {
26212       {
26213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26214       };
26215     }
26216   }
26217
26218   jresult = (void *)result;
26219   return jresult;
26220 }
26221
26222
26223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
26224   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
26225
26226   arg1 = (Dali::Shader::Hint *)jarg1;
26227   {
26228     try {
26229       delete arg1;
26230     } catch (std::out_of_range& e) {
26231       {
26232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26233       };
26234     } catch (std::exception& e) {
26235       {
26236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26237       };
26238     } catch (Dali::DaliException e) {
26239       {
26240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26241       };
26242     } catch (...) {
26243       {
26244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26245       };
26246     }
26247   }
26248
26249 }
26250
26251
26252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
26253   int jresult ;
26254   int result;
26255
26256   result = (int)Dali::Shader::Property::PROGRAM;
26257   jresult = (int)result;
26258   return jresult;
26259 }
26260
26261
26262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
26263   void * jresult ;
26264   Dali::Shader::Property *result = 0 ;
26265
26266   {
26267     try {
26268       result = (Dali::Shader::Property *)new Dali::Shader::Property();
26269     } catch (std::out_of_range& e) {
26270       {
26271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26272       };
26273     } catch (std::exception& e) {
26274       {
26275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26276       };
26277     } catch (Dali::DaliException e) {
26278       {
26279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26280       };
26281     } catch (...) {
26282       {
26283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26284       };
26285     }
26286   }
26287
26288   jresult = (void *)result;
26289   return jresult;
26290 }
26291
26292
26293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
26294   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
26295
26296   arg1 = (Dali::Shader::Property *)jarg1;
26297   {
26298     try {
26299       delete arg1;
26300     } catch (std::out_of_range& e) {
26301       {
26302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26303       };
26304     } catch (std::exception& e) {
26305       {
26306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26307       };
26308     } catch (Dali::DaliException e) {
26309       {
26310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26311       };
26312     } catch (...) {
26313       {
26314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26315       };
26316     }
26317   }
26318
26319 }
26320
26321
26322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26323   void * jresult ;
26324   std::string *arg1 = 0 ;
26325   std::string *arg2 = 0 ;
26326   Dali::Shader::Hint::Value arg3 ;
26327   Dali::Shader result;
26328
26329   if (!jarg1) {
26330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26331     return 0;
26332   }
26333   std::string arg1_str(jarg1);
26334   arg1 = &arg1_str;
26335   if (!jarg2) {
26336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26337     return 0;
26338   }
26339   std::string arg2_str(jarg2);
26340   arg2 = &arg2_str;
26341   arg3 = (Dali::Shader::Hint::Value)jarg3;
26342   {
26343     try {
26344       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26345     } catch (std::out_of_range& e) {
26346       {
26347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26348       };
26349     } catch (std::exception& e) {
26350       {
26351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26352       };
26353     } catch (Dali::DaliException e) {
26354       {
26355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26356       };
26357     } catch (...) {
26358       {
26359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26360       };
26361     }
26362   }
26363
26364   jresult = new Dali::Shader((const Dali::Shader &)result);
26365
26366   //argout typemap for const std::string&
26367
26368
26369   //argout typemap for const std::string&
26370
26371   return jresult;
26372 }
26373
26374
26375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26376   void * jresult ;
26377   std::string *arg1 = 0 ;
26378   std::string *arg2 = 0 ;
26379   Dali::Shader result;
26380
26381   if (!jarg1) {
26382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26383     return 0;
26384   }
26385   std::string arg1_str(jarg1);
26386   arg1 = &arg1_str;
26387   if (!jarg2) {
26388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26389     return 0;
26390   }
26391   std::string arg2_str(jarg2);
26392   arg2 = &arg2_str;
26393   {
26394     try {
26395       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26396     } catch (std::out_of_range& e) {
26397       {
26398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26399       };
26400     } catch (std::exception& e) {
26401       {
26402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26403       };
26404     } catch (Dali::DaliException e) {
26405       {
26406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26407       };
26408     } catch (...) {
26409       {
26410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26411       };
26412     }
26413   }
26414
26415   jresult = new Dali::Shader((const Dali::Shader &)result);
26416
26417   //argout typemap for const std::string&
26418
26419
26420   //argout typemap for const std::string&
26421
26422   return jresult;
26423 }
26424
26425
26426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26427   void * jresult ;
26428   Dali::Shader *result = 0 ;
26429
26430   {
26431     try {
26432       result = (Dali::Shader *)new Dali::Shader();
26433     } catch (std::out_of_range& e) {
26434       {
26435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26436       };
26437     } catch (std::exception& e) {
26438       {
26439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26440       };
26441     } catch (Dali::DaliException e) {
26442       {
26443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26444       };
26445     } catch (...) {
26446       {
26447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26448       };
26449     }
26450   }
26451
26452   jresult = (void *)result;
26453   return jresult;
26454 }
26455
26456
26457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26458   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26459
26460   arg1 = (Dali::Shader *)jarg1;
26461   {
26462     try {
26463       delete arg1;
26464     } catch (std::out_of_range& e) {
26465       {
26466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26467       };
26468     } catch (std::exception& e) {
26469       {
26470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26471       };
26472     } catch (Dali::DaliException e) {
26473       {
26474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26475       };
26476     } catch (...) {
26477       {
26478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26479       };
26480     }
26481   }
26482
26483 }
26484
26485
26486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26487   void * jresult ;
26488   Dali::Shader *arg1 = 0 ;
26489   Dali::Shader *result = 0 ;
26490
26491   arg1 = (Dali::Shader *)jarg1;
26492   if (!arg1) {
26493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26494     return 0;
26495   }
26496   {
26497     try {
26498       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26499     } catch (std::out_of_range& e) {
26500       {
26501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26502       };
26503     } catch (std::exception& e) {
26504       {
26505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26506       };
26507     } catch (Dali::DaliException e) {
26508       {
26509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26510       };
26511     } catch (...) {
26512       {
26513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26514       };
26515     }
26516   }
26517
26518   jresult = (void *)result;
26519   return jresult;
26520 }
26521
26522
26523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26524   void * jresult ;
26525   Dali::BaseHandle arg1 ;
26526   Dali::BaseHandle *argp1 ;
26527   Dali::Shader result;
26528
26529   argp1 = (Dali::BaseHandle *)jarg1;
26530   if (!argp1) {
26531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26532     return 0;
26533   }
26534   arg1 = *argp1;
26535   {
26536     try {
26537       result = Dali::Shader::DownCast(arg1);
26538     } catch (std::out_of_range& e) {
26539       {
26540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26541       };
26542     } catch (std::exception& e) {
26543       {
26544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26545       };
26546     } catch (Dali::DaliException e) {
26547       {
26548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26549       };
26550     } catch (...) {
26551       {
26552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26553       };
26554     }
26555   }
26556
26557   jresult = new Dali::Shader((const Dali::Shader &)result);
26558   return jresult;
26559 }
26560
26561
26562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26563   void * jresult ;
26564   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26565   Dali::Shader *arg2 = 0 ;
26566   Dali::Shader *result = 0 ;
26567
26568   arg1 = (Dali::Shader *)jarg1;
26569   arg2 = (Dali::Shader *)jarg2;
26570   if (!arg2) {
26571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26572     return 0;
26573   }
26574   {
26575     try {
26576       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26577     } catch (std::out_of_range& e) {
26578       {
26579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26580       };
26581     } catch (std::exception& e) {
26582       {
26583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26584       };
26585     } catch (Dali::DaliException e) {
26586       {
26587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26588       };
26589     } catch (...) {
26590       {
26591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26592       };
26593     }
26594   }
26595
26596   jresult = (void *)result;
26597   return jresult;
26598 }
26599
26600
26601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() {
26602   int jresult ;
26603   int result;
26604
26605   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT;
26606   jresult = (int)result;
26607   return jresult;
26608 }
26609
26610
26611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() {
26612   int jresult ;
26613   int result;
26614
26615   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND;
26616   jresult = (int)result;
26617   return jresult;
26618 }
26619
26620
26621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() {
26622   int jresult ;
26623   int result;
26624
26625   result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT;
26626   jresult = (int)result;
26627   return jresult;
26628 }
26629
26630
26631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() {
26632   int jresult ;
26633   int result;
26634
26635   result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION;
26636   jresult = (int)result;
26637   return jresult;
26638 }
26639
26640
26641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() {
26642   int jresult ;
26643   int result;
26644
26645   result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT;
26646   jresult = (int)result;
26647   return jresult;
26648 }
26649
26650
26651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26652   int jresult ;
26653   int result;
26654
26655   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26656   jresult = (int)result;
26657   return jresult;
26658 }
26659
26660
26661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26662   int jresult ;
26663   int result;
26664
26665   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26666   jresult = (int)result;
26667   return jresult;
26668 }
26669
26670
26671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26672   int jresult ;
26673   int result;
26674
26675   result = (int)Dali::Renderer::Property::BLEND_MODE;
26676   jresult = (int)result;
26677   return jresult;
26678 }
26679
26680
26681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26682   int jresult ;
26683   int result;
26684
26685   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26686   jresult = (int)result;
26687   return jresult;
26688 }
26689
26690
26691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26692   int jresult ;
26693   int result;
26694
26695   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26696   jresult = (int)result;
26697   return jresult;
26698 }
26699
26700
26701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26702   int jresult ;
26703   int result;
26704
26705   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26706   jresult = (int)result;
26707   return jresult;
26708 }
26709
26710
26711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26712   int jresult ;
26713   int result;
26714
26715   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26716   jresult = (int)result;
26717   return jresult;
26718 }
26719
26720
26721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26722   int jresult ;
26723   int result;
26724
26725   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26726   jresult = (int)result;
26727   return jresult;
26728 }
26729
26730
26731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26732   int jresult ;
26733   int result;
26734
26735   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26736   jresult = (int)result;
26737   return jresult;
26738 }
26739
26740
26741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26742   int jresult ;
26743   int result;
26744
26745   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26746   jresult = (int)result;
26747   return jresult;
26748 }
26749
26750
26751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26752   int jresult ;
26753   int result;
26754
26755   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26756   jresult = (int)result;
26757   return jresult;
26758 }
26759
26760
26761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26762   int jresult ;
26763   int result;
26764
26765   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26766   jresult = (int)result;
26767   return jresult;
26768 }
26769
26770
26771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26772   int jresult ;
26773   int result;
26774
26775   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26776   jresult = (int)result;
26777   return jresult;
26778 }
26779
26780
26781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26782   int jresult ;
26783   int result;
26784
26785   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26786   jresult = (int)result;
26787   return jresult;
26788 }
26789
26790
26791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26792   int jresult ;
26793   int result;
26794
26795   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26796   jresult = (int)result;
26797   return jresult;
26798 }
26799
26800
26801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26802   int jresult ;
26803   int result;
26804
26805   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26806   jresult = (int)result;
26807   return jresult;
26808 }
26809
26810
26811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26812   int jresult ;
26813   int result;
26814
26815   result = (int)Dali::Renderer::Property::RENDER_MODE;
26816   jresult = (int)result;
26817   return jresult;
26818 }
26819
26820
26821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26822   int jresult ;
26823   int result;
26824
26825   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26826   jresult = (int)result;
26827   return jresult;
26828 }
26829
26830
26831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26832   int jresult ;
26833   int result;
26834
26835   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26836   jresult = (int)result;
26837   return jresult;
26838 }
26839
26840
26841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26842   int jresult ;
26843   int result;
26844
26845   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26846   jresult = (int)result;
26847   return jresult;
26848 }
26849
26850
26851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26852   int jresult ;
26853   int result;
26854
26855   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26856   jresult = (int)result;
26857   return jresult;
26858 }
26859
26860
26861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26862   int jresult ;
26863   int result;
26864
26865   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26866   jresult = (int)result;
26867   return jresult;
26868 }
26869
26870
26871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26872   int jresult ;
26873   int result;
26874
26875   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26876   jresult = (int)result;
26877   return jresult;
26878 }
26879
26880
26881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26882   int jresult ;
26883   int result;
26884
26885   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26886   jresult = (int)result;
26887   return jresult;
26888 }
26889
26890
26891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26892   void * jresult ;
26893   Dali::Renderer::Property *result = 0 ;
26894
26895   {
26896     try {
26897       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26898     } catch (std::out_of_range& e) {
26899       {
26900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26901       };
26902     } catch (std::exception& e) {
26903       {
26904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26905       };
26906     } catch (Dali::DaliException e) {
26907       {
26908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26909       };
26910     } catch (...) {
26911       {
26912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26913       };
26914     }
26915   }
26916
26917   jresult = (void *)result;
26918   return jresult;
26919 }
26920
26921
26922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26923   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26924
26925   arg1 = (Dali::Renderer::Property *)jarg1;
26926   {
26927     try {
26928       delete arg1;
26929     } catch (std::out_of_range& e) {
26930       {
26931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26932       };
26933     } catch (std::exception& e) {
26934       {
26935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26936       };
26937     } catch (Dali::DaliException e) {
26938       {
26939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26940       };
26941     } catch (...) {
26942       {
26943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26944       };
26945     }
26946   }
26947
26948 }
26949
26950
26951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26952   void * jresult ;
26953   Dali::Geometry *arg1 = 0 ;
26954   Dali::Shader *arg2 = 0 ;
26955   Dali::Renderer result;
26956
26957   arg1 = (Dali::Geometry *)jarg1;
26958   if (!arg1) {
26959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26960     return 0;
26961   }
26962   arg2 = (Dali::Shader *)jarg2;
26963   if (!arg2) {
26964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26965     return 0;
26966   }
26967   {
26968     try {
26969       result = Dali::Renderer::New(*arg1,*arg2);
26970     } catch (std::out_of_range& e) {
26971       {
26972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26973       };
26974     } catch (std::exception& e) {
26975       {
26976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26977       };
26978     } catch (Dali::DaliException e) {
26979       {
26980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26981       };
26982     } catch (...) {
26983       {
26984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26985       };
26986     }
26987   }
26988
26989   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26990   return jresult;
26991 }
26992
26993
26994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26995   void * jresult ;
26996   Dali::Renderer *result = 0 ;
26997
26998   {
26999     try {
27000       result = (Dali::Renderer *)new Dali::Renderer();
27001     } catch (std::out_of_range& e) {
27002       {
27003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27004       };
27005     } catch (std::exception& e) {
27006       {
27007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27008       };
27009     } catch (Dali::DaliException e) {
27010       {
27011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27012       };
27013     } catch (...) {
27014       {
27015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27016       };
27017     }
27018   }
27019
27020   jresult = (void *)result;
27021   return jresult;
27022 }
27023
27024
27025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
27026   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27027
27028   arg1 = (Dali::Renderer *)jarg1;
27029   {
27030     try {
27031       delete arg1;
27032     } catch (std::out_of_range& e) {
27033       {
27034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27035       };
27036     } catch (std::exception& e) {
27037       {
27038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27039       };
27040     } catch (Dali::DaliException e) {
27041       {
27042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27043       };
27044     } catch (...) {
27045       {
27046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27047       };
27048     }
27049   }
27050
27051 }
27052
27053
27054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
27055   void * jresult ;
27056   Dali::Renderer *arg1 = 0 ;
27057   Dali::Renderer *result = 0 ;
27058
27059   arg1 = (Dali::Renderer *)jarg1;
27060   if (!arg1) {
27061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
27062     return 0;
27063   }
27064   {
27065     try {
27066       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
27067     } catch (std::out_of_range& e) {
27068       {
27069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27070       };
27071     } catch (std::exception& e) {
27072       {
27073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27074       };
27075     } catch (Dali::DaliException e) {
27076       {
27077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27078       };
27079     } catch (...) {
27080       {
27081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27082       };
27083     }
27084   }
27085
27086   jresult = (void *)result;
27087   return jresult;
27088 }
27089
27090
27091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
27092   void * jresult ;
27093   Dali::BaseHandle arg1 ;
27094   Dali::BaseHandle *argp1 ;
27095   Dali::Renderer result;
27096
27097   argp1 = (Dali::BaseHandle *)jarg1;
27098   if (!argp1) {
27099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27100     return 0;
27101   }
27102   arg1 = *argp1;
27103   {
27104     try {
27105       result = Dali::Renderer::DownCast(arg1);
27106     } catch (std::out_of_range& e) {
27107       {
27108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27109       };
27110     } catch (std::exception& e) {
27111       {
27112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27113       };
27114     } catch (Dali::DaliException e) {
27115       {
27116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27117       };
27118     } catch (...) {
27119       {
27120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27121       };
27122     }
27123   }
27124
27125   jresult = new Dali::Renderer((const Dali::Renderer &)result);
27126   return jresult;
27127 }
27128
27129
27130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
27131   void * jresult ;
27132   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27133   Dali::Renderer *arg2 = 0 ;
27134   Dali::Renderer *result = 0 ;
27135
27136   arg1 = (Dali::Renderer *)jarg1;
27137   arg2 = (Dali::Renderer *)jarg2;
27138   if (!arg2) {
27139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
27140     return 0;
27141   }
27142   {
27143     try {
27144       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
27145     } catch (std::out_of_range& e) {
27146       {
27147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27148       };
27149     } catch (std::exception& e) {
27150       {
27151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27152       };
27153     } catch (Dali::DaliException e) {
27154       {
27155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27156       };
27157     } catch (...) {
27158       {
27159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27160       };
27161     }
27162   }
27163
27164   jresult = (void *)result;
27165   return jresult;
27166 }
27167
27168
27169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
27170   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27171   Dali::Geometry *arg2 = 0 ;
27172
27173   arg1 = (Dali::Renderer *)jarg1;
27174   arg2 = (Dali::Geometry *)jarg2;
27175   if (!arg2) {
27176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
27177     return ;
27178   }
27179   {
27180     try {
27181       (arg1)->SetGeometry(*arg2);
27182     } catch (std::out_of_range& e) {
27183       {
27184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27185       };
27186     } catch (std::exception& e) {
27187       {
27188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27189       };
27190     } catch (Dali::DaliException e) {
27191       {
27192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27193       };
27194     } catch (...) {
27195       {
27196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27197       };
27198     }
27199   }
27200
27201 }
27202
27203
27204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
27205   void * jresult ;
27206   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27207   Dali::Geometry result;
27208
27209   arg1 = (Dali::Renderer *)jarg1;
27210   {
27211     try {
27212       result = ((Dali::Renderer const *)arg1)->GetGeometry();
27213     } catch (std::out_of_range& e) {
27214       {
27215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27216       };
27217     } catch (std::exception& e) {
27218       {
27219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27220       };
27221     } catch (Dali::DaliException e) {
27222       {
27223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27224       };
27225     } catch (...) {
27226       {
27227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27228       };
27229     }
27230   }
27231
27232   jresult = new Dali::Geometry((const Dali::Geometry &)result);
27233   return jresult;
27234 }
27235
27236
27237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
27238   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27239   int arg2 ;
27240   int arg3 ;
27241
27242   arg1 = (Dali::Renderer *)jarg1;
27243   arg2 = (int)jarg2;
27244   arg3 = (int)jarg3;
27245   {
27246     try {
27247       (arg1)->SetIndexRange(arg2,arg3);
27248     } catch (std::out_of_range& e) {
27249       {
27250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27251       };
27252     } catch (std::exception& e) {
27253       {
27254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27255       };
27256     } catch (Dali::DaliException e) {
27257       {
27258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27259       };
27260     } catch (...) {
27261       {
27262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27263       };
27264     }
27265   }
27266
27267 }
27268
27269
27270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
27271   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27272   Dali::TextureSet *arg2 = 0 ;
27273
27274   arg1 = (Dali::Renderer *)jarg1;
27275   arg2 = (Dali::TextureSet *)jarg2;
27276   if (!arg2) {
27277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
27278     return ;
27279   }
27280   {
27281     try {
27282       (arg1)->SetTextures(*arg2);
27283     } catch (std::out_of_range& e) {
27284       {
27285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27286       };
27287     } catch (std::exception& e) {
27288       {
27289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27290       };
27291     } catch (Dali::DaliException e) {
27292       {
27293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27294       };
27295     } catch (...) {
27296       {
27297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27298       };
27299     }
27300   }
27301
27302 }
27303
27304
27305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
27306   void * jresult ;
27307   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27308   Dali::TextureSet result;
27309
27310   arg1 = (Dali::Renderer *)jarg1;
27311   {
27312     try {
27313       result = ((Dali::Renderer const *)arg1)->GetTextures();
27314     } catch (std::out_of_range& e) {
27315       {
27316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27317       };
27318     } catch (std::exception& e) {
27319       {
27320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27321       };
27322     } catch (Dali::DaliException e) {
27323       {
27324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27325       };
27326     } catch (...) {
27327       {
27328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27329       };
27330     }
27331   }
27332
27333   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27334   return jresult;
27335 }
27336
27337
27338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27339   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27340   Dali::Shader *arg2 = 0 ;
27341
27342   arg1 = (Dali::Renderer *)jarg1;
27343   arg2 = (Dali::Shader *)jarg2;
27344   if (!arg2) {
27345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27346     return ;
27347   }
27348   {
27349     try {
27350       (arg1)->SetShader(*arg2);
27351     } catch (std::out_of_range& e) {
27352       {
27353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27354       };
27355     } catch (std::exception& e) {
27356       {
27357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27358       };
27359     } catch (Dali::DaliException e) {
27360       {
27361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27362       };
27363     } catch (...) {
27364       {
27365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27366       };
27367     }
27368   }
27369
27370 }
27371
27372
27373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27374   void * jresult ;
27375   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27376   Dali::Shader result;
27377
27378   arg1 = (Dali::Renderer *)jarg1;
27379   {
27380     try {
27381       result = ((Dali::Renderer const *)arg1)->GetShader();
27382     } catch (std::out_of_range& e) {
27383       {
27384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27385       };
27386     } catch (std::exception& e) {
27387       {
27388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27389       };
27390     } catch (Dali::DaliException e) {
27391       {
27392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27393       };
27394     } catch (...) {
27395       {
27396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27397       };
27398     }
27399   }
27400
27401   jresult = new Dali::Shader((const Dali::Shader &)result);
27402   return jresult;
27403 }
27404
27405
27406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27407   void * jresult ;
27408   Dali::FrameBuffer::Attachment *result = 0 ;
27409
27410   {
27411     try {
27412       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27413     } catch (std::out_of_range& e) {
27414       {
27415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27416       };
27417     } catch (std::exception& e) {
27418       {
27419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27420       };
27421     } catch (Dali::DaliException e) {
27422       {
27423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27424       };
27425     } catch (...) {
27426       {
27427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27428       };
27429     }
27430   }
27431
27432   jresult = (void *)result;
27433   return jresult;
27434 }
27435
27436
27437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27438   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27439
27440   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27441   {
27442     try {
27443       delete arg1;
27444     } catch (std::out_of_range& e) {
27445       {
27446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27447       };
27448     } catch (std::exception& e) {
27449       {
27450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27451       };
27452     } catch (Dali::DaliException e) {
27453       {
27454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27455       };
27456     } catch (...) {
27457       {
27458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27459       };
27460     }
27461   }
27462
27463 }
27464
27465
27466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27467   void * jresult ;
27468   unsigned int arg1 ;
27469   unsigned int arg2 ;
27470   unsigned int arg3 ;
27471   Dali::FrameBuffer result;
27472
27473   arg1 = (unsigned int)jarg1;
27474   arg2 = (unsigned int)jarg2;
27475   arg3 = (unsigned int)jarg3;
27476   {
27477     try {
27478       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
27479     } catch (std::out_of_range& e) {
27480       {
27481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27482       };
27483     } catch (std::exception& e) {
27484       {
27485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27486       };
27487     } catch (Dali::DaliException e) {
27488       {
27489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27490       };
27491     } catch (...) {
27492       {
27493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27494       };
27495     }
27496   }
27497
27498   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27499   return jresult;
27500 }
27501
27502
27503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27504   void * jresult ;
27505   Dali::FrameBuffer *result = 0 ;
27506
27507   {
27508     try {
27509       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27510     } catch (std::out_of_range& e) {
27511       {
27512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27513       };
27514     } catch (std::exception& e) {
27515       {
27516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27517       };
27518     } catch (Dali::DaliException e) {
27519       {
27520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27521       };
27522     } catch (...) {
27523       {
27524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27525       };
27526     }
27527   }
27528
27529   jresult = (void *)result;
27530   return jresult;
27531 }
27532
27533
27534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27535   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27536
27537   arg1 = (Dali::FrameBuffer *)jarg1;
27538   {
27539     try {
27540       delete arg1;
27541     } catch (std::out_of_range& e) {
27542       {
27543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27544       };
27545     } catch (std::exception& e) {
27546       {
27547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27548       };
27549     } catch (Dali::DaliException e) {
27550       {
27551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27552       };
27553     } catch (...) {
27554       {
27555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27556       };
27557     }
27558   }
27559
27560 }
27561
27562
27563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27564   void * jresult ;
27565   Dali::FrameBuffer *arg1 = 0 ;
27566   Dali::FrameBuffer *result = 0 ;
27567
27568   arg1 = (Dali::FrameBuffer *)jarg1;
27569   if (!arg1) {
27570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27571     return 0;
27572   }
27573   {
27574     try {
27575       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27576     } catch (std::out_of_range& e) {
27577       {
27578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27579       };
27580     } catch (std::exception& e) {
27581       {
27582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27583       };
27584     } catch (Dali::DaliException e) {
27585       {
27586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27587       };
27588     } catch (...) {
27589       {
27590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27591       };
27592     }
27593   }
27594
27595   jresult = (void *)result;
27596   return jresult;
27597 }
27598
27599
27600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27601   void * jresult ;
27602   Dali::BaseHandle arg1 ;
27603   Dali::BaseHandle *argp1 ;
27604   Dali::FrameBuffer result;
27605
27606   argp1 = (Dali::BaseHandle *)jarg1;
27607   if (!argp1) {
27608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27609     return 0;
27610   }
27611   arg1 = *argp1;
27612   {
27613     try {
27614       result = Dali::FrameBuffer::DownCast(arg1);
27615     } catch (std::out_of_range& e) {
27616       {
27617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27618       };
27619     } catch (std::exception& e) {
27620       {
27621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27622       };
27623     } catch (Dali::DaliException e) {
27624       {
27625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27626       };
27627     } catch (...) {
27628       {
27629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27630       };
27631     }
27632   }
27633
27634   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27635   return jresult;
27636 }
27637
27638
27639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27640   void * jresult ;
27641   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27642   Dali::FrameBuffer *arg2 = 0 ;
27643   Dali::FrameBuffer *result = 0 ;
27644
27645   arg1 = (Dali::FrameBuffer *)jarg1;
27646   arg2 = (Dali::FrameBuffer *)jarg2;
27647   if (!arg2) {
27648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27649     return 0;
27650   }
27651   {
27652     try {
27653       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27654     } catch (std::out_of_range& e) {
27655       {
27656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27657       };
27658     } catch (std::exception& e) {
27659       {
27660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27661       };
27662     } catch (Dali::DaliException e) {
27663       {
27664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27665       };
27666     } catch (...) {
27667       {
27668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27669       };
27670     }
27671   }
27672
27673   jresult = (void *)result;
27674   return jresult;
27675 }
27676
27677
27678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27679   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27680   Dali::Texture *arg2 = 0 ;
27681
27682   arg1 = (Dali::FrameBuffer *)jarg1;
27683   arg2 = (Dali::Texture *)jarg2;
27684   if (!arg2) {
27685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27686     return ;
27687   }
27688   {
27689     try {
27690       (arg1)->AttachColorTexture(*arg2);
27691     } catch (std::out_of_range& e) {
27692       {
27693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27694       };
27695     } catch (std::exception& e) {
27696       {
27697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27698       };
27699     } catch (Dali::DaliException e) {
27700       {
27701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27702       };
27703     } catch (...) {
27704       {
27705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27706       };
27707     }
27708   }
27709
27710 }
27711
27712
27713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27714   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27715   Dali::Texture *arg2 = 0 ;
27716   unsigned int arg3 ;
27717   unsigned int arg4 ;
27718
27719   arg1 = (Dali::FrameBuffer *)jarg1;
27720   arg2 = (Dali::Texture *)jarg2;
27721   if (!arg2) {
27722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27723     return ;
27724   }
27725   arg3 = (unsigned int)jarg3;
27726   arg4 = (unsigned int)jarg4;
27727   {
27728     try {
27729       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27730     } catch (std::out_of_range& e) {
27731       {
27732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27733       };
27734     } catch (std::exception& e) {
27735       {
27736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27737       };
27738     } catch (Dali::DaliException e) {
27739       {
27740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27741       };
27742     } catch (...) {
27743       {
27744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27745       };
27746     }
27747   }
27748
27749 }
27750
27751
27752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27753   void * jresult ;
27754   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27755   Dali::Texture result;
27756
27757   arg1 = (Dali::FrameBuffer *)jarg1;
27758   {
27759     try {
27760       result = (arg1)->GetColorTexture();
27761     } catch (std::out_of_range& e) {
27762       {
27763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27764       };
27765     } catch (std::exception& e) {
27766       {
27767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27768       };
27769     } catch (Dali::DaliException e) {
27770       {
27771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27772       };
27773     } catch (...) {
27774       {
27775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27776       };
27777     }
27778   }
27779
27780   jresult = new Dali::Texture((const Dali::Texture &)result);
27781   return jresult;
27782 }
27783
27784
27785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27786   void * jresult ;
27787   Dali::RenderTaskList *result = 0 ;
27788
27789   {
27790     try {
27791       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27792     } catch (std::out_of_range& e) {
27793       {
27794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27795       };
27796     } catch (std::exception& e) {
27797       {
27798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27799       };
27800     } catch (Dali::DaliException e) {
27801       {
27802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27803       };
27804     } catch (...) {
27805       {
27806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27807       };
27808     }
27809   }
27810
27811   jresult = (void *)result;
27812   return jresult;
27813 }
27814
27815
27816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27817   void * jresult ;
27818   Dali::BaseHandle arg1 ;
27819   Dali::BaseHandle *argp1 ;
27820   Dali::RenderTaskList result;
27821
27822   argp1 = (Dali::BaseHandle *)jarg1;
27823   if (!argp1) {
27824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27825     return 0;
27826   }
27827   arg1 = *argp1;
27828   {
27829     try {
27830       result = Dali::RenderTaskList::DownCast(arg1);
27831     } catch (std::out_of_range& e) {
27832       {
27833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27834       };
27835     } catch (std::exception& e) {
27836       {
27837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27838       };
27839     } catch (Dali::DaliException e) {
27840       {
27841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27842       };
27843     } catch (...) {
27844       {
27845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27846       };
27847     }
27848   }
27849
27850   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27851   return jresult;
27852 }
27853
27854
27855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27856   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27857
27858   arg1 = (Dali::RenderTaskList *)jarg1;
27859   {
27860     try {
27861       delete arg1;
27862     } catch (std::out_of_range& e) {
27863       {
27864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27865       };
27866     } catch (std::exception& e) {
27867       {
27868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27869       };
27870     } catch (Dali::DaliException e) {
27871       {
27872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27873       };
27874     } catch (...) {
27875       {
27876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27877       };
27878     }
27879   }
27880
27881 }
27882
27883
27884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27885   void * jresult ;
27886   Dali::RenderTaskList *arg1 = 0 ;
27887   Dali::RenderTaskList *result = 0 ;
27888
27889   arg1 = (Dali::RenderTaskList *)jarg1;
27890   if (!arg1) {
27891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27892     return 0;
27893   }
27894   {
27895     try {
27896       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27897     } catch (std::out_of_range& e) {
27898       {
27899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27900       };
27901     } catch (std::exception& e) {
27902       {
27903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27904       };
27905     } catch (Dali::DaliException e) {
27906       {
27907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27908       };
27909     } catch (...) {
27910       {
27911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27912       };
27913     }
27914   }
27915
27916   jresult = (void *)result;
27917   return jresult;
27918 }
27919
27920
27921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27922   void * jresult ;
27923   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27924   Dali::RenderTaskList *arg2 = 0 ;
27925   Dali::RenderTaskList *result = 0 ;
27926
27927   arg1 = (Dali::RenderTaskList *)jarg1;
27928   arg2 = (Dali::RenderTaskList *)jarg2;
27929   if (!arg2) {
27930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27931     return 0;
27932   }
27933   {
27934     try {
27935       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27936     } catch (std::out_of_range& e) {
27937       {
27938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27939       };
27940     } catch (std::exception& e) {
27941       {
27942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27943       };
27944     } catch (Dali::DaliException e) {
27945       {
27946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27947       };
27948     } catch (...) {
27949       {
27950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27951       };
27952     }
27953   }
27954
27955   jresult = (void *)result;
27956   return jresult;
27957 }
27958
27959
27960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27961   void * jresult ;
27962   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27963   Dali::RenderTask result;
27964
27965   arg1 = (Dali::RenderTaskList *)jarg1;
27966   {
27967     try {
27968       result = (arg1)->CreateTask();
27969     } catch (std::out_of_range& e) {
27970       {
27971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27972       };
27973     } catch (std::exception& e) {
27974       {
27975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27976       };
27977     } catch (Dali::DaliException e) {
27978       {
27979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27980       };
27981     } catch (...) {
27982       {
27983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27984       };
27985     }
27986   }
27987
27988   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27989   return jresult;
27990 }
27991
27992
27993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27994   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27995   Dali::RenderTask arg2 ;
27996   Dali::RenderTask *argp2 ;
27997
27998   arg1 = (Dali::RenderTaskList *)jarg1;
27999   argp2 = (Dali::RenderTask *)jarg2;
28000   if (!argp2) {
28001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
28002     return ;
28003   }
28004   arg2 = *argp2;
28005   {
28006     try {
28007       (arg1)->RemoveTask(arg2);
28008     } catch (std::out_of_range& e) {
28009       {
28010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28011       };
28012     } catch (std::exception& e) {
28013       {
28014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28015       };
28016     } catch (Dali::DaliException e) {
28017       {
28018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28019       };
28020     } catch (...) {
28021       {
28022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28023       };
28024     }
28025   }
28026
28027 }
28028
28029
28030 //// ===============================================end part 1 =================
28031
28032 //// ========================= part 2 ===============================
28033
28034 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
28035   unsigned int jresult ;
28036   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
28037   unsigned int result;
28038
28039   arg1 = (Dali::RenderTaskList *)jarg1;
28040   {
28041     try {
28042       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
28043     } catch (std::out_of_range& e) {
28044       {
28045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28046       };
28047     } catch (std::exception& e) {
28048       {
28049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28050       };
28051     } catch (Dali::DaliException e) {
28052       {
28053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28054       };
28055     } catch (...) {
28056       {
28057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28058       };
28059     }
28060   }
28061
28062   jresult = result;
28063   return jresult;
28064 }
28065
28066
28067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
28068   void * jresult ;
28069   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
28070   unsigned int arg2 ;
28071   Dali::RenderTask result;
28072
28073   arg1 = (Dali::RenderTaskList *)jarg1;
28074   arg2 = (unsigned int)jarg2;
28075   {
28076     try {
28077       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
28078     } catch (std::out_of_range& e) {
28079       {
28080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28081       };
28082     } catch (std::exception& e) {
28083       {
28084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28085       };
28086     } catch (Dali::DaliException e) {
28087       {
28088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28089       };
28090     } catch (...) {
28091       {
28092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28093       };
28094     }
28095   }
28096
28097   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28098   return jresult;
28099 }
28100
28101
28102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
28103   int jresult ;
28104   int result;
28105
28106   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
28107   jresult = (int)result;
28108   return jresult;
28109 }
28110
28111
28112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
28113   int jresult ;
28114   int result;
28115
28116   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
28117   jresult = (int)result;
28118   return jresult;
28119 }
28120
28121
28122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
28123   int jresult ;
28124   int result;
28125
28126   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
28127   jresult = (int)result;
28128   return jresult;
28129 }
28130
28131
28132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
28133   int jresult ;
28134   int result;
28135
28136   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
28137   jresult = (int)result;
28138   return jresult;
28139 }
28140
28141
28142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
28143   void * jresult ;
28144   Dali::RenderTask::Property *result = 0 ;
28145
28146   {
28147     try {
28148       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
28149     } catch (std::out_of_range& e) {
28150       {
28151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28152       };
28153     } catch (std::exception& e) {
28154       {
28155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28156       };
28157     } catch (Dali::DaliException e) {
28158       {
28159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28160       };
28161     } catch (...) {
28162       {
28163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28164       };
28165     }
28166   }
28167
28168   jresult = (void *)result;
28169   return jresult;
28170 }
28171
28172
28173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
28174   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
28175
28176   arg1 = (Dali::RenderTask::Property *)jarg1;
28177   {
28178     try {
28179       delete arg1;
28180     } catch (std::out_of_range& e) {
28181       {
28182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28183       };
28184     } catch (std::exception& e) {
28185       {
28186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28187       };
28188     } catch (Dali::DaliException e) {
28189       {
28190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28191       };
28192     } catch (...) {
28193       {
28194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28195       };
28196     }
28197   }
28198
28199 }
28200
28201
28202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
28203   void * jresult ;
28204   bool (*result)(Dali::Vector2 &) = 0 ;
28205
28206   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
28207   jresult = (void *)result;
28208   return jresult;
28209 }
28210
28211
28212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
28213   void * jresult ;
28214   bool (*result)(Dali::Vector2 &) = 0 ;
28215
28216   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
28217   jresult = (void *)result;
28218   return jresult;
28219 }
28220
28221
28222 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
28223   unsigned int jresult ;
28224   bool result;
28225
28226   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
28227   jresult = result;
28228   return jresult;
28229 }
28230
28231
28232 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
28233   unsigned int jresult ;
28234   bool result;
28235
28236   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
28237   jresult = result;
28238   return jresult;
28239 }
28240
28241
28242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
28243   void * jresult ;
28244   Dali::Vector4 *result = 0 ;
28245
28246   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
28247   jresult = (void *)result;
28248   return jresult;
28249 }
28250
28251
28252 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
28253   unsigned int jresult ;
28254   bool result;
28255
28256   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
28257   jresult = result;
28258   return jresult;
28259 }
28260
28261
28262 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
28263   unsigned int jresult ;
28264   bool result;
28265
28266   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
28267   jresult = result;
28268   return jresult;
28269 }
28270
28271
28272 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
28273   unsigned int jresult ;
28274   unsigned int result;
28275
28276   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
28277   jresult = result;
28278   return jresult;
28279 }
28280
28281
28282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
28283   void * jresult ;
28284   Dali::RenderTask *result = 0 ;
28285
28286   {
28287     try {
28288       result = (Dali::RenderTask *)new Dali::RenderTask();
28289     } catch (std::out_of_range& e) {
28290       {
28291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28292       };
28293     } catch (std::exception& e) {
28294       {
28295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28296       };
28297     } catch (Dali::DaliException e) {
28298       {
28299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28300       };
28301     } catch (...) {
28302       {
28303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28304       };
28305     }
28306   }
28307
28308   jresult = (void *)result;
28309   return jresult;
28310 }
28311
28312
28313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28314   void * jresult ;
28315   Dali::BaseHandle arg1 ;
28316   Dali::BaseHandle *argp1 ;
28317   Dali::RenderTask result;
28318
28319   argp1 = (Dali::BaseHandle *)jarg1;
28320   if (!argp1) {
28321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28322     return 0;
28323   }
28324   arg1 = *argp1;
28325   {
28326     try {
28327       result = Dali::RenderTask::DownCast(arg1);
28328     } catch (std::out_of_range& e) {
28329       {
28330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28331       };
28332     } catch (std::exception& e) {
28333       {
28334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28335       };
28336     } catch (Dali::DaliException e) {
28337       {
28338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28339       };
28340     } catch (...) {
28341       {
28342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28343       };
28344     }
28345   }
28346
28347   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28348   return jresult;
28349 }
28350
28351
28352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28353   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28354
28355   arg1 = (Dali::RenderTask *)jarg1;
28356   {
28357     try {
28358       delete arg1;
28359     } catch (std::out_of_range& e) {
28360       {
28361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28362       };
28363     } catch (std::exception& e) {
28364       {
28365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28366       };
28367     } catch (Dali::DaliException e) {
28368       {
28369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28370       };
28371     } catch (...) {
28372       {
28373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28374       };
28375     }
28376   }
28377
28378 }
28379
28380
28381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28382   void * jresult ;
28383   Dali::RenderTask *arg1 = 0 ;
28384   Dali::RenderTask *result = 0 ;
28385
28386   arg1 = (Dali::RenderTask *)jarg1;
28387   if (!arg1) {
28388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28389     return 0;
28390   }
28391   {
28392     try {
28393       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28394     } catch (std::out_of_range& e) {
28395       {
28396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28397       };
28398     } catch (std::exception& e) {
28399       {
28400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28401       };
28402     } catch (Dali::DaliException e) {
28403       {
28404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28405       };
28406     } catch (...) {
28407       {
28408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28409       };
28410     }
28411   }
28412
28413   jresult = (void *)result;
28414   return jresult;
28415 }
28416
28417
28418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28419   void * jresult ;
28420   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28421   Dali::RenderTask *arg2 = 0 ;
28422   Dali::RenderTask *result = 0 ;
28423
28424   arg1 = (Dali::RenderTask *)jarg1;
28425   arg2 = (Dali::RenderTask *)jarg2;
28426   if (!arg2) {
28427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28428     return 0;
28429   }
28430   {
28431     try {
28432       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28433     } catch (std::out_of_range& e) {
28434       {
28435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28436       };
28437     } catch (std::exception& e) {
28438       {
28439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28440       };
28441     } catch (Dali::DaliException e) {
28442       {
28443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28444       };
28445     } catch (...) {
28446       {
28447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28448       };
28449     }
28450   }
28451
28452   jresult = (void *)result;
28453   return jresult;
28454 }
28455
28456
28457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28458   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28459   Dali::Actor arg2 ;
28460   Dali::Actor *argp2 ;
28461
28462   arg1 = (Dali::RenderTask *)jarg1;
28463   argp2 = (Dali::Actor *)jarg2;
28464   if (!argp2) {
28465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28466     return ;
28467   }
28468   arg2 = *argp2;
28469   {
28470     try {
28471       (arg1)->SetSourceActor(arg2);
28472     } catch (std::out_of_range& e) {
28473       {
28474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28475       };
28476     } catch (std::exception& e) {
28477       {
28478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28479       };
28480     } catch (Dali::DaliException e) {
28481       {
28482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28483       };
28484     } catch (...) {
28485       {
28486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28487       };
28488     }
28489   }
28490
28491 }
28492
28493
28494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28495   void * jresult ;
28496   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28497   Dali::Actor result;
28498
28499   arg1 = (Dali::RenderTask *)jarg1;
28500   {
28501     try {
28502       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28503     } catch (std::out_of_range& e) {
28504       {
28505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28506       };
28507     } catch (std::exception& e) {
28508       {
28509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28510       };
28511     } catch (Dali::DaliException e) {
28512       {
28513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28514       };
28515     } catch (...) {
28516       {
28517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28518       };
28519     }
28520   }
28521
28522   jresult = new Dali::Actor((const Dali::Actor &)result);
28523   return jresult;
28524 }
28525
28526
28527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28528   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28529   bool arg2 ;
28530
28531   arg1 = (Dali::RenderTask *)jarg1;
28532   arg2 = jarg2 ? true : false;
28533   {
28534     try {
28535       (arg1)->SetExclusive(arg2);
28536     } catch (std::out_of_range& e) {
28537       {
28538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28539       };
28540     } catch (std::exception& e) {
28541       {
28542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28543       };
28544     } catch (Dali::DaliException e) {
28545       {
28546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28547       };
28548     } catch (...) {
28549       {
28550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28551       };
28552     }
28553   }
28554
28555 }
28556
28557
28558 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28559   unsigned int jresult ;
28560   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28561   bool result;
28562
28563   arg1 = (Dali::RenderTask *)jarg1;
28564   {
28565     try {
28566       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28567     } catch (std::out_of_range& e) {
28568       {
28569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28570       };
28571     } catch (std::exception& e) {
28572       {
28573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28574       };
28575     } catch (Dali::DaliException e) {
28576       {
28577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28578       };
28579     } catch (...) {
28580       {
28581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28582       };
28583     }
28584   }
28585
28586   jresult = result;
28587   return jresult;
28588 }
28589
28590
28591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28592   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28593   bool arg2 ;
28594
28595   arg1 = (Dali::RenderTask *)jarg1;
28596   arg2 = jarg2 ? true : false;
28597   {
28598     try {
28599       (arg1)->SetInputEnabled(arg2);
28600     } catch (std::out_of_range& e) {
28601       {
28602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28603       };
28604     } catch (std::exception& e) {
28605       {
28606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28607       };
28608     } catch (Dali::DaliException e) {
28609       {
28610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28611       };
28612     } catch (...) {
28613       {
28614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28615       };
28616     }
28617   }
28618
28619 }
28620
28621
28622 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28623   unsigned int jresult ;
28624   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28625   bool result;
28626
28627   arg1 = (Dali::RenderTask *)jarg1;
28628   {
28629     try {
28630       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28631     } catch (std::out_of_range& e) {
28632       {
28633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28634       };
28635     } catch (std::exception& e) {
28636       {
28637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28638       };
28639     } catch (Dali::DaliException e) {
28640       {
28641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28642       };
28643     } catch (...) {
28644       {
28645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28646       };
28647     }
28648   }
28649
28650   jresult = result;
28651   return jresult;
28652 }
28653
28654
28655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28656   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28657   Dali::CameraActor arg2 ;
28658   Dali::CameraActor *argp2 ;
28659
28660   arg1 = (Dali::RenderTask *)jarg1;
28661   argp2 = (Dali::CameraActor *)jarg2;
28662   if (!argp2) {
28663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28664     return ;
28665   }
28666   arg2 = *argp2;
28667   {
28668     try {
28669       (arg1)->SetCameraActor(arg2);
28670     } catch (std::out_of_range& e) {
28671       {
28672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28673       };
28674     } catch (std::exception& e) {
28675       {
28676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28677       };
28678     } catch (Dali::DaliException e) {
28679       {
28680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28681       };
28682     } catch (...) {
28683       {
28684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28685       };
28686     }
28687   }
28688
28689 }
28690
28691
28692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28693   void * jresult ;
28694   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28695   Dali::CameraActor result;
28696
28697   arg1 = (Dali::RenderTask *)jarg1;
28698   {
28699     try {
28700       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28701     } catch (std::out_of_range& e) {
28702       {
28703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28704       };
28705     } catch (std::exception& e) {
28706       {
28707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28708       };
28709     } catch (Dali::DaliException e) {
28710       {
28711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28712       };
28713     } catch (...) {
28714       {
28715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28716       };
28717     }
28718   }
28719
28720   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28721   return jresult;
28722 }
28723
28724
28725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
28726   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28727   Dali::FrameBufferImage arg2 ;
28728   Dali::FrameBufferImage *argp2 ;
28729
28730   arg1 = (Dali::RenderTask *)jarg1;
28731   argp2 = (Dali::FrameBufferImage *)jarg2;
28732   if (!argp2) {
28733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
28734     return ;
28735   }
28736   arg2 = *argp2;
28737   {
28738     try {
28739       (arg1)->SetTargetFrameBuffer(arg2);
28740     } catch (std::out_of_range& e) {
28741       {
28742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28743       };
28744     } catch (std::exception& e) {
28745       {
28746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28747       };
28748     } catch (Dali::DaliException e) {
28749       {
28750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28751       };
28752     } catch (...) {
28753       {
28754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28755       };
28756     }
28757   }
28758
28759 }
28760
28761
28762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
28763   void * jresult ;
28764   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28765   Dali::FrameBufferImage result;
28766
28767   arg1 = (Dali::RenderTask *)jarg1;
28768   {
28769     try {
28770       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
28771     } catch (std::out_of_range& e) {
28772       {
28773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28774       };
28775     } catch (std::exception& e) {
28776       {
28777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28778       };
28779     } catch (Dali::DaliException e) {
28780       {
28781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28782       };
28783     } catch (...) {
28784       {
28785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28786       };
28787     }
28788   }
28789
28790   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
28791   return jresult;
28792 }
28793
28794
28795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28796   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28797   Dali::FrameBuffer arg2 ;
28798   Dali::FrameBuffer *argp2 ;
28799
28800   arg1 = (Dali::RenderTask *)jarg1;
28801   argp2 = (Dali::FrameBuffer *)jarg2;
28802   if (!argp2) {
28803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28804     return ;
28805   }
28806   arg2 = *argp2;
28807   {
28808     try {
28809       (arg1)->SetFrameBuffer(arg2);
28810     } catch (std::out_of_range& e) {
28811       {
28812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28813       };
28814     } catch (std::exception& e) {
28815       {
28816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28817       };
28818     } catch (Dali::DaliException e) {
28819       {
28820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28821       };
28822     } catch (...) {
28823       {
28824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28825       };
28826     }
28827   }
28828
28829 }
28830
28831
28832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28833   void * jresult ;
28834   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28835   Dali::FrameBuffer result;
28836
28837   arg1 = (Dali::RenderTask *)jarg1;
28838   {
28839     try {
28840       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28841     } catch (std::out_of_range& e) {
28842       {
28843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28844       };
28845     } catch (std::exception& e) {
28846       {
28847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28848       };
28849     } catch (Dali::DaliException e) {
28850       {
28851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28852       };
28853     } catch (...) {
28854       {
28855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28856       };
28857     }
28858   }
28859
28860   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28861   return jresult;
28862 }
28863
28864
28865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28866   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28867   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28868
28869   arg1 = (Dali::RenderTask *)jarg1;
28870   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28871   {
28872     try {
28873       (arg1)->SetScreenToFrameBufferFunction(arg2);
28874     } catch (std::out_of_range& e) {
28875       {
28876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28877       };
28878     } catch (std::exception& e) {
28879       {
28880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28881       };
28882     } catch (Dali::DaliException e) {
28883       {
28884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28885       };
28886     } catch (...) {
28887       {
28888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28889       };
28890     }
28891   }
28892
28893 }
28894
28895
28896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28897   void * jresult ;
28898   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28899   Dali::RenderTask::ScreenToFrameBufferFunction result;
28900
28901   arg1 = (Dali::RenderTask *)jarg1;
28902   {
28903     try {
28904       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28905     } catch (std::out_of_range& e) {
28906       {
28907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28908       };
28909     } catch (std::exception& e) {
28910       {
28911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28912       };
28913     } catch (Dali::DaliException e) {
28914       {
28915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28916       };
28917     } catch (...) {
28918       {
28919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28920       };
28921     }
28922   }
28923
28924   jresult = (void *)result;
28925   return jresult;
28926 }
28927
28928
28929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28930   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28931   Dali::Actor arg2 ;
28932   Dali::Actor *argp2 ;
28933
28934   arg1 = (Dali::RenderTask *)jarg1;
28935   argp2 = (Dali::Actor *)jarg2;
28936   if (!argp2) {
28937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28938     return ;
28939   }
28940   arg2 = *argp2;
28941   {
28942     try {
28943       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28944     } catch (std::out_of_range& e) {
28945       {
28946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28947       };
28948     } catch (std::exception& e) {
28949       {
28950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28951       };
28952     } catch (Dali::DaliException e) {
28953       {
28954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28955       };
28956     } catch (...) {
28957       {
28958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28959       };
28960     }
28961   }
28962
28963 }
28964
28965
28966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28967   void * jresult ;
28968   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28969   Dali::Actor result;
28970
28971   arg1 = (Dali::RenderTask *)jarg1;
28972   {
28973     try {
28974       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28975     } catch (std::out_of_range& e) {
28976       {
28977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28978       };
28979     } catch (std::exception& e) {
28980       {
28981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28982       };
28983     } catch (Dali::DaliException e) {
28984       {
28985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28986       };
28987     } catch (...) {
28988       {
28989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28990       };
28991     }
28992   }
28993
28994   jresult = new Dali::Actor((const Dali::Actor &)result);
28995   return jresult;
28996 }
28997
28998
28999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
29000   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29001   Dali::Vector2 arg2 ;
29002   Dali::Vector2 *argp2 ;
29003
29004   arg1 = (Dali::RenderTask *)jarg1;
29005   argp2 = (Dali::Vector2 *)jarg2;
29006   if (!argp2) {
29007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
29008     return ;
29009   }
29010   arg2 = *argp2;
29011   {
29012     try {
29013       (arg1)->SetViewportPosition(arg2);
29014     } catch (std::out_of_range& e) {
29015       {
29016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29017       };
29018     } catch (std::exception& e) {
29019       {
29020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29021       };
29022     } catch (Dali::DaliException e) {
29023       {
29024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29025       };
29026     } catch (...) {
29027       {
29028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29029       };
29030     }
29031   }
29032
29033 }
29034
29035
29036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
29037   void * jresult ;
29038   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29039   Dali::Vector2 result;
29040
29041   arg1 = (Dali::RenderTask *)jarg1;
29042   {
29043     try {
29044       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
29045     } catch (std::out_of_range& e) {
29046       {
29047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29048       };
29049     } catch (std::exception& e) {
29050       {
29051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29052       };
29053     } catch (Dali::DaliException e) {
29054       {
29055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29056       };
29057     } catch (...) {
29058       {
29059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29060       };
29061     }
29062   }
29063
29064   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29065   return jresult;
29066 }
29067
29068
29069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
29070   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29071   Dali::Vector2 arg2 ;
29072   Dali::Vector2 *argp2 ;
29073
29074   arg1 = (Dali::RenderTask *)jarg1;
29075   argp2 = (Dali::Vector2 *)jarg2;
29076   if (!argp2) {
29077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
29078     return ;
29079   }
29080   arg2 = *argp2;
29081   {
29082     try {
29083       (arg1)->SetViewportSize(arg2);
29084     } catch (std::out_of_range& e) {
29085       {
29086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29087       };
29088     } catch (std::exception& e) {
29089       {
29090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29091       };
29092     } catch (Dali::DaliException e) {
29093       {
29094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29095       };
29096     } catch (...) {
29097       {
29098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29099       };
29100     }
29101   }
29102
29103 }
29104
29105
29106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
29107   void * jresult ;
29108   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29109   Dali::Vector2 result;
29110
29111   arg1 = (Dali::RenderTask *)jarg1;
29112   {
29113     try {
29114       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
29115     } catch (std::out_of_range& e) {
29116       {
29117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29118       };
29119     } catch (std::exception& e) {
29120       {
29121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29122       };
29123     } catch (Dali::DaliException e) {
29124       {
29125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29126       };
29127     } catch (...) {
29128       {
29129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29130       };
29131     }
29132   }
29133
29134   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29135   return jresult;
29136 }
29137
29138
29139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
29140   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29141   Dali::Viewport arg2 ;
29142   Dali::Viewport *argp2 ;
29143
29144   arg1 = (Dali::RenderTask *)jarg1;
29145   argp2 = (Dali::Viewport *)jarg2;
29146   if (!argp2) {
29147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
29148     return ;
29149   }
29150   arg2 = *argp2;
29151   {
29152     try {
29153       (arg1)->SetViewport(arg2);
29154     } catch (std::out_of_range& e) {
29155       {
29156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29157       };
29158     } catch (std::exception& e) {
29159       {
29160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29161       };
29162     } catch (Dali::DaliException e) {
29163       {
29164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29165       };
29166     } catch (...) {
29167       {
29168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29169       };
29170     }
29171   }
29172
29173 }
29174
29175
29176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
29177   void * jresult ;
29178   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29179   Dali::Viewport result;
29180
29181   arg1 = (Dali::RenderTask *)jarg1;
29182   {
29183     try {
29184       result = ((Dali::RenderTask const *)arg1)->GetViewport();
29185     } catch (std::out_of_range& e) {
29186       {
29187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29188       };
29189     } catch (std::exception& e) {
29190       {
29191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29192       };
29193     } catch (Dali::DaliException e) {
29194       {
29195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29196       };
29197     } catch (...) {
29198       {
29199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29200       };
29201     }
29202   }
29203
29204   jresult = new Dali::Viewport((const Dali::Viewport &)result);
29205   return jresult;
29206 }
29207
29208
29209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
29210   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29211   Dali::Vector4 *arg2 = 0 ;
29212
29213   arg1 = (Dali::RenderTask *)jarg1;
29214   arg2 = (Dali::Vector4 *)jarg2;
29215   if (!arg2) {
29216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
29217     return ;
29218   }
29219   {
29220     try {
29221       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
29222     } catch (std::out_of_range& e) {
29223       {
29224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29225       };
29226     } catch (std::exception& e) {
29227       {
29228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29229       };
29230     } catch (Dali::DaliException e) {
29231       {
29232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29233       };
29234     } catch (...) {
29235       {
29236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29237       };
29238     }
29239   }
29240
29241 }
29242
29243
29244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
29245   void * jresult ;
29246   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29247   Dali::Vector4 result;
29248
29249   arg1 = (Dali::RenderTask *)jarg1;
29250   {
29251     try {
29252       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
29253     } catch (std::out_of_range& e) {
29254       {
29255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29256       };
29257     } catch (std::exception& e) {
29258       {
29259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29260       };
29261     } catch (Dali::DaliException e) {
29262       {
29263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29264       };
29265     } catch (...) {
29266       {
29267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29268       };
29269     }
29270   }
29271
29272   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
29273   return jresult;
29274 }
29275
29276
29277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
29278   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29279   bool arg2 ;
29280
29281   arg1 = (Dali::RenderTask *)jarg1;
29282   arg2 = jarg2 ? true : false;
29283   {
29284     try {
29285       (arg1)->SetClearEnabled(arg2);
29286     } catch (std::out_of_range& e) {
29287       {
29288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29289       };
29290     } catch (std::exception& e) {
29291       {
29292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29293       };
29294     } catch (Dali::DaliException e) {
29295       {
29296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29297       };
29298     } catch (...) {
29299       {
29300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29301       };
29302     }
29303   }
29304
29305 }
29306
29307
29308 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
29309   unsigned int jresult ;
29310   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29311   bool result;
29312
29313   arg1 = (Dali::RenderTask *)jarg1;
29314   {
29315     try {
29316       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
29317     } catch (std::out_of_range& e) {
29318       {
29319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29320       };
29321     } catch (std::exception& e) {
29322       {
29323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29324       };
29325     } catch (Dali::DaliException e) {
29326       {
29327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29328       };
29329     } catch (...) {
29330       {
29331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29332       };
29333     }
29334   }
29335
29336   jresult = result;
29337   return jresult;
29338 }
29339
29340
29341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
29342   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29343   bool arg2 ;
29344
29345   arg1 = (Dali::RenderTask *)jarg1;
29346   arg2 = jarg2 ? true : false;
29347   {
29348     try {
29349       (arg1)->SetCullMode(arg2);
29350     } catch (std::out_of_range& e) {
29351       {
29352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29353       };
29354     } catch (std::exception& e) {
29355       {
29356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29357       };
29358     } catch (Dali::DaliException e) {
29359       {
29360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29361       };
29362     } catch (...) {
29363       {
29364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29365       };
29366     }
29367   }
29368
29369 }
29370
29371
29372 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
29373   unsigned int jresult ;
29374   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29375   bool result;
29376
29377   arg1 = (Dali::RenderTask *)jarg1;
29378   {
29379     try {
29380       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29381     } catch (std::out_of_range& e) {
29382       {
29383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29384       };
29385     } catch (std::exception& e) {
29386       {
29387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29388       };
29389     } catch (Dali::DaliException e) {
29390       {
29391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29392       };
29393     } catch (...) {
29394       {
29395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29396       };
29397     }
29398   }
29399
29400   jresult = result;
29401   return jresult;
29402 }
29403
29404
29405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29406   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29407   unsigned int arg2 ;
29408
29409   arg1 = (Dali::RenderTask *)jarg1;
29410   arg2 = (unsigned int)jarg2;
29411   {
29412     try {
29413       (arg1)->SetRefreshRate(arg2);
29414     } catch (std::out_of_range& e) {
29415       {
29416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29417       };
29418     } catch (std::exception& e) {
29419       {
29420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29421       };
29422     } catch (Dali::DaliException e) {
29423       {
29424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29425       };
29426     } catch (...) {
29427       {
29428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29429       };
29430     }
29431   }
29432
29433 }
29434
29435
29436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29437   unsigned int jresult ;
29438   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29439   unsigned int result;
29440
29441   arg1 = (Dali::RenderTask *)jarg1;
29442   {
29443     try {
29444       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29445     } catch (std::out_of_range& e) {
29446       {
29447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29448       };
29449     } catch (std::exception& e) {
29450       {
29451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29452       };
29453     } catch (Dali::DaliException e) {
29454       {
29455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29456       };
29457     } catch (...) {
29458       {
29459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29460       };
29461     }
29462   }
29463
29464   jresult = result;
29465   return jresult;
29466 }
29467
29468
29469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29470   unsigned int jresult ;
29471   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29472   Dali::Vector3 *arg2 = 0 ;
29473   float *arg3 = 0 ;
29474   float *arg4 = 0 ;
29475   bool result;
29476
29477   arg1 = (Dali::RenderTask *)jarg1;
29478   arg2 = (Dali::Vector3 *)jarg2;
29479   if (!arg2) {
29480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29481     return 0;
29482   }
29483   arg3 = (float *)jarg3;
29484   arg4 = (float *)jarg4;
29485   {
29486     try {
29487       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29488     } catch (std::out_of_range& e) {
29489       {
29490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29491       };
29492     } catch (std::exception& e) {
29493       {
29494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29495       };
29496     } catch (Dali::DaliException e) {
29497       {
29498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29499       };
29500     } catch (...) {
29501       {
29502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29503       };
29504     }
29505   }
29506
29507   jresult = result;
29508   return jresult;
29509 }
29510
29511
29512 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29513   unsigned int jresult ;
29514   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29515   Dali::Actor arg2 ;
29516   float arg3 ;
29517   float arg4 ;
29518   float *arg5 = 0 ;
29519   float *arg6 = 0 ;
29520   Dali::Actor *argp2 ;
29521   bool result;
29522
29523   arg1 = (Dali::RenderTask *)jarg1;
29524   argp2 = (Dali::Actor *)jarg2;
29525   if (!argp2) {
29526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29527     return 0;
29528   }
29529   arg2 = *argp2;
29530   arg3 = (float)jarg3;
29531   arg4 = (float)jarg4;
29532   arg5 = (float *)jarg5;
29533   arg6 = (float *)jarg6;
29534   {
29535     try {
29536       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29537     } catch (std::out_of_range& e) {
29538       {
29539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29540       };
29541     } catch (std::exception& e) {
29542       {
29543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29544       };
29545     } catch (Dali::DaliException e) {
29546       {
29547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29548       };
29549     } catch (...) {
29550       {
29551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29552       };
29553     }
29554   }
29555
29556   jresult = result;
29557   return jresult;
29558 }
29559
29560
29561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29562   void * jresult ;
29563   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29564   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29565
29566   arg1 = (Dali::RenderTask *)jarg1;
29567   {
29568     try {
29569       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
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 void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29595   void * jresult ;
29596   int arg1 ;
29597   Dali::TouchPoint::State arg2 ;
29598   float arg3 ;
29599   float arg4 ;
29600   Dali::TouchPoint *result = 0 ;
29601
29602   arg1 = (int)jarg1;
29603   arg2 = (Dali::TouchPoint::State)jarg2;
29604   arg3 = (float)jarg3;
29605   arg4 = (float)jarg4;
29606   {
29607     try {
29608       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29609     } catch (std::out_of_range& e) {
29610       {
29611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29612       };
29613     } catch (std::exception& e) {
29614       {
29615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29616       };
29617     } catch (Dali::DaliException e) {
29618       {
29619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29620       };
29621     } catch (...) {
29622       {
29623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29624       };
29625     }
29626   }
29627
29628   jresult = (void *)result;
29629   return jresult;
29630 }
29631
29632
29633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29634   void * jresult ;
29635   int arg1 ;
29636   Dali::TouchPoint::State arg2 ;
29637   float arg3 ;
29638   float arg4 ;
29639   float arg5 ;
29640   float arg6 ;
29641   Dali::TouchPoint *result = 0 ;
29642
29643   arg1 = (int)jarg1;
29644   arg2 = (Dali::TouchPoint::State)jarg2;
29645   arg3 = (float)jarg3;
29646   arg4 = (float)jarg4;
29647   arg5 = (float)jarg5;
29648   arg6 = (float)jarg6;
29649   {
29650     try {
29651       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29652     } catch (std::out_of_range& e) {
29653       {
29654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29655       };
29656     } catch (std::exception& e) {
29657       {
29658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29659       };
29660     } catch (Dali::DaliException e) {
29661       {
29662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29663       };
29664     } catch (...) {
29665       {
29666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29667       };
29668     }
29669   }
29670
29671   jresult = (void *)result;
29672   return jresult;
29673 }
29674
29675
29676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29677   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29678
29679   arg1 = (Dali::TouchPoint *)jarg1;
29680   {
29681     try {
29682       delete arg1;
29683     } catch (std::out_of_range& e) {
29684       {
29685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29686       };
29687     } catch (std::exception& e) {
29688       {
29689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29690       };
29691     } catch (Dali::DaliException e) {
29692       {
29693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29694       };
29695     } catch (...) {
29696       {
29697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29698       };
29699     }
29700   }
29701
29702 }
29703
29704
29705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29706   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29707   int arg2 ;
29708
29709   arg1 = (Dali::TouchPoint *)jarg1;
29710   arg2 = (int)jarg2;
29711   if (arg1) (arg1)->deviceId = arg2;
29712 }
29713
29714
29715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29716   int jresult ;
29717   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29718   int result;
29719
29720   arg1 = (Dali::TouchPoint *)jarg1;
29721   result = (int) ((arg1)->deviceId);
29722   jresult = result;
29723   return jresult;
29724 }
29725
29726
29727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29728   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29729   Dali::TouchPoint::State arg2 ;
29730
29731   arg1 = (Dali::TouchPoint *)jarg1;
29732   arg2 = (Dali::TouchPoint::State)jarg2;
29733   if (arg1) (arg1)->state = arg2;
29734 }
29735
29736
29737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29738   int jresult ;
29739   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29740   Dali::TouchPoint::State result;
29741
29742   arg1 = (Dali::TouchPoint *)jarg1;
29743   result = (Dali::TouchPoint::State) ((arg1)->state);
29744   jresult = (int)result;
29745   return jresult;
29746 }
29747
29748
29749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29750   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29751   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29752
29753   arg1 = (Dali::TouchPoint *)jarg1;
29754   arg2 = (Dali::Actor *)jarg2;
29755   if (arg1) (arg1)->hitActor = *arg2;
29756 }
29757
29758
29759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29760   void * jresult ;
29761   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29762   Dali::Actor *result = 0 ;
29763
29764   arg1 = (Dali::TouchPoint *)jarg1;
29765   result = (Dali::Actor *)& ((arg1)->hitActor);
29766   jresult = (void *)result;
29767   return jresult;
29768 }
29769
29770
29771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29772   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29773   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29774
29775   arg1 = (Dali::TouchPoint *)jarg1;
29776   arg2 = (Dali::Vector2 *)jarg2;
29777   if (arg1) (arg1)->local = *arg2;
29778 }
29779
29780
29781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29782   void * jresult ;
29783   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29784   Dali::Vector2 *result = 0 ;
29785
29786   arg1 = (Dali::TouchPoint *)jarg1;
29787   result = (Dali::Vector2 *)& ((arg1)->local);
29788   jresult = (void *)result;
29789   return jresult;
29790 }
29791
29792
29793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29794   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29795   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29796
29797   arg1 = (Dali::TouchPoint *)jarg1;
29798   arg2 = (Dali::Vector2 *)jarg2;
29799   if (arg1) (arg1)->screen = *arg2;
29800 }
29801
29802
29803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29804   void * jresult ;
29805   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29806   Dali::Vector2 *result = 0 ;
29807
29808   arg1 = (Dali::TouchPoint *)jarg1;
29809   result = (Dali::Vector2 *)& ((arg1)->screen);
29810   jresult = (void *)result;
29811   return jresult;
29812 }
29813
29814
29815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29816   void * jresult ;
29817   Dali::TouchData *result = 0 ;
29818
29819   {
29820     try {
29821       result = (Dali::TouchData *)new Dali::TouchData();
29822     } catch (std::out_of_range& e) {
29823       {
29824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29825       };
29826     } catch (std::exception& e) {
29827       {
29828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29829       };
29830     } catch (Dali::DaliException e) {
29831       {
29832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29833       };
29834     } catch (...) {
29835       {
29836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29837       };
29838     }
29839   }
29840
29841   jresult = (void *)result;
29842   return jresult;
29843 }
29844
29845
29846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29847   void * jresult ;
29848   Dali::TouchData *arg1 = 0 ;
29849   Dali::TouchData *result = 0 ;
29850
29851   arg1 = (Dali::TouchData *)jarg1;
29852   if (!arg1) {
29853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29854     return 0;
29855   }
29856   {
29857     try {
29858       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
29859     } catch (std::out_of_range& e) {
29860       {
29861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29862       };
29863     } catch (std::exception& e) {
29864       {
29865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29866       };
29867     } catch (Dali::DaliException e) {
29868       {
29869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29870       };
29871     } catch (...) {
29872       {
29873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29874       };
29875     }
29876   }
29877
29878   jresult = (void *)result;
29879   return jresult;
29880 }
29881
29882
29883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29884   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29885
29886   arg1 = (Dali::TouchData *)jarg1;
29887   {
29888     try {
29889       delete arg1;
29890     } catch (std::out_of_range& e) {
29891       {
29892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29893       };
29894     } catch (std::exception& e) {
29895       {
29896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29897       };
29898     } catch (Dali::DaliException e) {
29899       {
29900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29901       };
29902     } catch (...) {
29903       {
29904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29905       };
29906     }
29907   }
29908
29909 }
29910
29911
29912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29913   void * jresult ;
29914   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29915   Dali::TouchData *arg2 = 0 ;
29916   Dali::TouchData *result = 0 ;
29917
29918   arg1 = (Dali::TouchData *)jarg1;
29919   arg2 = (Dali::TouchData *)jarg2;
29920   if (!arg2) {
29921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29922     return 0;
29923   }
29924   {
29925     try {
29926       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29927     } catch (std::out_of_range& e) {
29928       {
29929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29930       };
29931     } catch (std::exception& e) {
29932       {
29933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29934       };
29935     } catch (Dali::DaliException e) {
29936       {
29937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29938       };
29939     } catch (...) {
29940       {
29941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29942       };
29943     }
29944   }
29945
29946   jresult = (void *)result;
29947   return jresult;
29948 }
29949
29950
29951 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29952   unsigned long jresult ;
29953   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29954   unsigned long result;
29955
29956   arg1 = (Dali::TouchData *)jarg1;
29957   {
29958     try {
29959       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29960     } catch (std::out_of_range& e) {
29961       {
29962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29963       };
29964     } catch (std::exception& e) {
29965       {
29966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29967       };
29968     } catch (Dali::DaliException e) {
29969       {
29970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29971       };
29972     } catch (...) {
29973       {
29974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29975       };
29976     }
29977   }
29978
29979   jresult = (unsigned long)result;
29980   return jresult;
29981 }
29982
29983
29984 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29985   unsigned long jresult ;
29986   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29987   std::size_t result;
29988
29989   arg1 = (Dali::TouchData *)jarg1;
29990   {
29991     try {
29992       result = ((Dali::TouchData const *)arg1)->GetPointCount();
29993     } catch (std::out_of_range& e) {
29994       {
29995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29996       };
29997     } catch (std::exception& e) {
29998       {
29999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30000       };
30001     } catch (Dali::DaliException e) {
30002       {
30003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30004       };
30005     } catch (...) {
30006       {
30007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30008       };
30009     }
30010   }
30011
30012   jresult = (unsigned long)result;
30013   return jresult;
30014 }
30015
30016
30017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
30018   int jresult ;
30019   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30020   std::size_t arg2 ;
30021   int32_t result;
30022
30023   arg1 = (Dali::TouchData *)jarg1;
30024   arg2 = (std::size_t)jarg2;
30025   {
30026     try {
30027       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
30028     } catch (std::out_of_range& e) {
30029       {
30030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30031       };
30032     } catch (std::exception& e) {
30033       {
30034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30035       };
30036     } catch (Dali::DaliException e) {
30037       {
30038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30039       };
30040     } catch (...) {
30041       {
30042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30043       };
30044     }
30045   }
30046
30047   jresult = result;
30048   return jresult;
30049 }
30050
30051
30052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
30053   int jresult ;
30054   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30055   std::size_t arg2 ;
30056   Dali::PointState::Type result;
30057
30058   arg1 = (Dali::TouchData *)jarg1;
30059   arg2 = (std::size_t)jarg2;
30060   {
30061     try {
30062       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
30063     } catch (std::out_of_range& e) {
30064       {
30065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30066       };
30067     } catch (std::exception& e) {
30068       {
30069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30070       };
30071     } catch (Dali::DaliException e) {
30072       {
30073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30074       };
30075     } catch (...) {
30076       {
30077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30078       };
30079     }
30080   }
30081
30082   jresult = (int)result;
30083   return jresult;
30084 }
30085
30086
30087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
30088   void * jresult ;
30089   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30090   std::size_t arg2 ;
30091   Dali::Actor result;
30092
30093   arg1 = (Dali::TouchData *)jarg1;
30094   arg2 = (std::size_t)jarg2;
30095   {
30096     try {
30097       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
30098     } catch (std::out_of_range& e) {
30099       {
30100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30101       };
30102     } catch (std::exception& e) {
30103       {
30104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30105       };
30106     } catch (Dali::DaliException e) {
30107       {
30108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30109       };
30110     } catch (...) {
30111       {
30112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30113       };
30114     }
30115   }
30116
30117   jresult = new Dali::Actor((const Dali::Actor &)result);
30118   return jresult;
30119 }
30120
30121
30122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
30123   void * jresult ;
30124   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30125   std::size_t arg2 ;
30126   Dali::Vector2 *result = 0 ;
30127
30128   arg1 = (Dali::TouchData *)jarg1;
30129   arg2 = (std::size_t)jarg2;
30130   {
30131     try {
30132       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
30133     } catch (std::out_of_range& e) {
30134       {
30135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30136       };
30137     } catch (std::exception& e) {
30138       {
30139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30140       };
30141     } catch (Dali::DaliException e) {
30142       {
30143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30144       };
30145     } catch (...) {
30146       {
30147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30148       };
30149     }
30150   }
30151
30152   jresult = (void *)result;
30153   return jresult;
30154 }
30155
30156
30157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
30158   void * jresult ;
30159   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30160   std::size_t arg2 ;
30161   Dali::Vector2 *result = 0 ;
30162
30163   arg1 = (Dali::TouchData *)jarg1;
30164   arg2 = (std::size_t)jarg2;
30165   {
30166     try {
30167       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
30168     } catch (std::out_of_range& e) {
30169       {
30170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30171       };
30172     } catch (std::exception& e) {
30173       {
30174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30175       };
30176     } catch (Dali::DaliException e) {
30177       {
30178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30179       };
30180     } catch (...) {
30181       {
30182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30183       };
30184     }
30185   }
30186
30187   jresult = (void *)result;
30188   return jresult;
30189 }
30190
30191
30192 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
30193   float jresult ;
30194   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30195   std::size_t arg2 ;
30196   float result;
30197
30198   arg1 = (Dali::TouchData *)jarg1;
30199   arg2 = (std::size_t)jarg2;
30200   {
30201     try {
30202       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
30203     } catch (std::out_of_range& e) {
30204       {
30205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30206       };
30207     } catch (std::exception& e) {
30208       {
30209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30210       };
30211     } catch (Dali::DaliException e) {
30212       {
30213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30214       };
30215     } catch (...) {
30216       {
30217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30218       };
30219     }
30220   }
30221
30222   jresult = result;
30223   return jresult;
30224 }
30225
30226
30227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
30228   void * jresult ;
30229   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30230   std::size_t arg2 ;
30231   Dali::Vector2 *result = 0 ;
30232
30233   arg1 = (Dali::TouchData *)jarg1;
30234   arg2 = (std::size_t)jarg2;
30235   {
30236     try {
30237       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
30238     } catch (std::out_of_range& e) {
30239       {
30240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30241       };
30242     } catch (std::exception& e) {
30243       {
30244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30245       };
30246     } catch (Dali::DaliException e) {
30247       {
30248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30249       };
30250     } catch (...) {
30251       {
30252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30253       };
30254     }
30255   }
30256
30257   jresult = (void *)result;
30258   return jresult;
30259 }
30260
30261
30262 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
30263   float jresult ;
30264   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30265   std::size_t arg2 ;
30266   float result;
30267
30268   arg1 = (Dali::TouchData *)jarg1;
30269   arg2 = (std::size_t)jarg2;
30270   {
30271     try {
30272       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
30273     } catch (std::out_of_range& e) {
30274       {
30275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30276       };
30277     } catch (std::exception& e) {
30278       {
30279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30280       };
30281     } catch (Dali::DaliException e) {
30282       {
30283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30284       };
30285     } catch (...) {
30286       {
30287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30288       };
30289     }
30290   }
30291
30292   jresult = result;
30293   return jresult;
30294 }
30295
30296
30297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
30298   void * jresult ;
30299   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30300   std::size_t arg2 ;
30301   Dali::Degree result;
30302
30303   arg1 = (Dali::TouchData *)jarg1;
30304   arg2 = (std::size_t)jarg2;
30305   {
30306     try {
30307       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
30308     } catch (std::out_of_range& e) {
30309       {
30310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30311       };
30312     } catch (std::exception& e) {
30313       {
30314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30315       };
30316     } catch (Dali::DaliException e) {
30317       {
30318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30319       };
30320     } catch (...) {
30321       {
30322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30323       };
30324     }
30325   }
30326
30327   jresult = new Dali::Degree((const Dali::Degree &)result);
30328   return jresult;
30329 }
30330
30331
30332 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
30333   int jresult ;
30334   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30335   std::size_t arg2 ;
30336   Dali::MouseButton::Type result;
30337
30338   arg1 = (Dali::TouchData *)jarg1;
30339   arg2 = (std::size_t)jarg2;
30340   {
30341     try {
30342       result = ((Dali::TouchData const *)arg1)->GetMouseButton(arg2);
30343     } catch (std::out_of_range& e) {
30344       {
30345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30346       };
30347     } catch (std::exception& e) {
30348       {
30349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30350       };
30351     } catch (Dali::DaliException e) {
30352       {
30353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30354       };
30355     } catch (...) {
30356       {
30357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30358       };
30359     }
30360   }
30361
30362   jresult = static_cast< int >(result);
30363   return jresult;
30364 }
30365
30366
30367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30368   void * jresult ;
30369   Dali::GestureDetector *result = 0 ;
30370
30371   {
30372     try {
30373       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30374     } catch (std::out_of_range& e) {
30375       {
30376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30377       };
30378     } catch (std::exception& e) {
30379       {
30380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30381       };
30382     } catch (Dali::DaliException e) {
30383       {
30384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30385       };
30386     } catch (...) {
30387       {
30388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30389       };
30390     }
30391   }
30392
30393   jresult = (void *)result;
30394   return jresult;
30395 }
30396
30397
30398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30399   void * jresult ;
30400   Dali::BaseHandle arg1 ;
30401   Dali::BaseHandle *argp1 ;
30402   Dali::GestureDetector result;
30403
30404   argp1 = (Dali::BaseHandle *)jarg1;
30405   if (!argp1) {
30406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30407     return 0;
30408   }
30409   arg1 = *argp1;
30410   {
30411     try {
30412       result = Dali::GestureDetector::DownCast(arg1);
30413     } catch (std::out_of_range& e) {
30414       {
30415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30416       };
30417     } catch (std::exception& e) {
30418       {
30419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30420       };
30421     } catch (Dali::DaliException e) {
30422       {
30423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30424       };
30425     } catch (...) {
30426       {
30427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30428       };
30429     }
30430   }
30431
30432   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30433   return jresult;
30434 }
30435
30436
30437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30438   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30439
30440   arg1 = (Dali::GestureDetector *)jarg1;
30441   {
30442     try {
30443       delete arg1;
30444     } catch (std::out_of_range& e) {
30445       {
30446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30447       };
30448     } catch (std::exception& e) {
30449       {
30450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30451       };
30452     } catch (Dali::DaliException e) {
30453       {
30454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30455       };
30456     } catch (...) {
30457       {
30458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30459       };
30460     }
30461   }
30462
30463 }
30464
30465
30466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30467   void * jresult ;
30468   Dali::GestureDetector *arg1 = 0 ;
30469   Dali::GestureDetector *result = 0 ;
30470
30471   arg1 = (Dali::GestureDetector *)jarg1;
30472   if (!arg1) {
30473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30474     return 0;
30475   }
30476   {
30477     try {
30478       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30479     } catch (std::out_of_range& e) {
30480       {
30481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30482       };
30483     } catch (std::exception& e) {
30484       {
30485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30486       };
30487     } catch (Dali::DaliException e) {
30488       {
30489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30490       };
30491     } catch (...) {
30492       {
30493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30494       };
30495     }
30496   }
30497
30498   jresult = (void *)result;
30499   return jresult;
30500 }
30501
30502
30503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30504   void * jresult ;
30505   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30506   Dali::GestureDetector *arg2 = 0 ;
30507   Dali::GestureDetector *result = 0 ;
30508
30509   arg1 = (Dali::GestureDetector *)jarg1;
30510   arg2 = (Dali::GestureDetector *)jarg2;
30511   if (!arg2) {
30512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30513     return 0;
30514   }
30515   {
30516     try {
30517       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30518     } catch (std::out_of_range& e) {
30519       {
30520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30521       };
30522     } catch (std::exception& e) {
30523       {
30524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30525       };
30526     } catch (Dali::DaliException e) {
30527       {
30528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30529       };
30530     } catch (...) {
30531       {
30532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30533       };
30534     }
30535   }
30536
30537   jresult = (void *)result;
30538   return jresult;
30539 }
30540
30541
30542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30543   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30544   Dali::Actor arg2 ;
30545   Dali::Actor *argp2 ;
30546
30547   arg1 = (Dali::GestureDetector *)jarg1;
30548   argp2 = (Dali::Actor *)jarg2;
30549   if (!argp2) {
30550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30551     return ;
30552   }
30553   arg2 = *argp2;
30554   {
30555     try {
30556       (arg1)->Attach(arg2);
30557     } catch (std::out_of_range& e) {
30558       {
30559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30560       };
30561     } catch (std::exception& e) {
30562       {
30563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30564       };
30565     } catch (Dali::DaliException e) {
30566       {
30567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30568       };
30569     } catch (...) {
30570       {
30571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30572       };
30573     }
30574   }
30575
30576 }
30577
30578
30579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30580   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30581   Dali::Actor arg2 ;
30582   Dali::Actor *argp2 ;
30583
30584   arg1 = (Dali::GestureDetector *)jarg1;
30585   argp2 = (Dali::Actor *)jarg2;
30586   if (!argp2) {
30587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30588     return ;
30589   }
30590   arg2 = *argp2;
30591   {
30592     try {
30593       (arg1)->Detach(arg2);
30594     } catch (std::out_of_range& e) {
30595       {
30596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30597       };
30598     } catch (std::exception& e) {
30599       {
30600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30601       };
30602     } catch (Dali::DaliException e) {
30603       {
30604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30605       };
30606     } catch (...) {
30607       {
30608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30609       };
30610     }
30611   }
30612
30613 }
30614
30615
30616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30617   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30618
30619   arg1 = (Dali::GestureDetector *)jarg1;
30620   {
30621     try {
30622       (arg1)->DetachAll();
30623     } catch (std::out_of_range& e) {
30624       {
30625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30626       };
30627     } catch (std::exception& e) {
30628       {
30629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30630       };
30631     } catch (Dali::DaliException e) {
30632       {
30633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30634       };
30635     } catch (...) {
30636       {
30637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30638       };
30639     }
30640   }
30641
30642 }
30643
30644
30645 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30646   unsigned long jresult ;
30647   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30648   size_t result;
30649
30650   arg1 = (Dali::GestureDetector *)jarg1;
30651   {
30652     try {
30653       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30654     } catch (std::out_of_range& e) {
30655       {
30656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30657       };
30658     } catch (std::exception& e) {
30659       {
30660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30661       };
30662     } catch (Dali::DaliException e) {
30663       {
30664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30665       };
30666     } catch (...) {
30667       {
30668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30669       };
30670     }
30671   }
30672
30673   jresult = (unsigned long)result;
30674   return jresult;
30675 }
30676
30677
30678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30679   void * jresult ;
30680   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30681   size_t arg2 ;
30682   Dali::Actor result;
30683
30684   arg1 = (Dali::GestureDetector *)jarg1;
30685   arg2 = (size_t)jarg2;
30686   {
30687     try {
30688       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30689     } catch (std::out_of_range& e) {
30690       {
30691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30692       };
30693     } catch (std::exception& e) {
30694       {
30695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30696       };
30697     } catch (Dali::DaliException e) {
30698       {
30699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30700       };
30701     } catch (...) {
30702       {
30703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30704       };
30705     }
30706   }
30707
30708   jresult = new Dali::Actor((const Dali::Actor &)result);
30709   return jresult;
30710 }
30711
30712
30713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30714   void * jresult ;
30715   Dali::Gesture *arg1 = 0 ;
30716   Dali::Gesture *result = 0 ;
30717
30718   arg1 = (Dali::Gesture *)jarg1;
30719   if (!arg1) {
30720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30721     return 0;
30722   }
30723   {
30724     try {
30725       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30726     } catch (std::out_of_range& e) {
30727       {
30728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30729       };
30730     } catch (std::exception& e) {
30731       {
30732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30733       };
30734     } catch (Dali::DaliException e) {
30735       {
30736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30737       };
30738     } catch (...) {
30739       {
30740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30741       };
30742     }
30743   }
30744
30745   jresult = (void *)result;
30746   return jresult;
30747 }
30748
30749
30750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30751   void * jresult ;
30752   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30753   Dali::Gesture *arg2 = 0 ;
30754   Dali::Gesture *result = 0 ;
30755
30756   arg1 = (Dali::Gesture *)jarg1;
30757   arg2 = (Dali::Gesture *)jarg2;
30758   if (!arg2) {
30759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30760     return 0;
30761   }
30762   {
30763     try {
30764       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30765     } catch (std::out_of_range& e) {
30766       {
30767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30768       };
30769     } catch (std::exception& e) {
30770       {
30771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30772       };
30773     } catch (Dali::DaliException e) {
30774       {
30775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30776       };
30777     } catch (...) {
30778       {
30779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30780       };
30781     }
30782   }
30783
30784   jresult = (void *)result;
30785   return jresult;
30786 }
30787
30788
30789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30790   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30791
30792   arg1 = (Dali::Gesture *)jarg1;
30793   {
30794     try {
30795       delete arg1;
30796     } catch (std::out_of_range& e) {
30797       {
30798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30799       };
30800     } catch (std::exception& e) {
30801       {
30802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30803       };
30804     } catch (Dali::DaliException e) {
30805       {
30806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30807       };
30808     } catch (...) {
30809       {
30810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30811       };
30812     }
30813   }
30814
30815 }
30816
30817
30818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30819   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30820   Dali::Gesture::Type arg2 ;
30821
30822   arg1 = (Dali::Gesture *)jarg1;
30823   arg2 = (Dali::Gesture::Type)jarg2;
30824   if (arg1) (arg1)->type = arg2;
30825 }
30826
30827
30828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30829   int jresult ;
30830   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30831   Dali::Gesture::Type result;
30832
30833   arg1 = (Dali::Gesture *)jarg1;
30834   result = (Dali::Gesture::Type) ((arg1)->type);
30835   jresult = (int)result;
30836   return jresult;
30837 }
30838
30839
30840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30841   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30842   Dali::Gesture::State arg2 ;
30843
30844   arg1 = (Dali::Gesture *)jarg1;
30845   arg2 = (Dali::Gesture::State)jarg2;
30846   if (arg1) (arg1)->state = arg2;
30847 }
30848
30849
30850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30851   int jresult ;
30852   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30853   Dali::Gesture::State result;
30854
30855   arg1 = (Dali::Gesture *)jarg1;
30856   result = (Dali::Gesture::State) ((arg1)->state);
30857   jresult = (int)result;
30858   return jresult;
30859 }
30860
30861
30862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30863   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30864   unsigned int arg2 ;
30865
30866   arg1 = (Dali::Gesture *)jarg1;
30867   arg2 = (unsigned int)jarg2;
30868   if (arg1) (arg1)->time = arg2;
30869 }
30870
30871
30872 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30873   unsigned int jresult ;
30874   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30875   unsigned int result;
30876
30877   arg1 = (Dali::Gesture *)jarg1;
30878   result = (unsigned int) ((arg1)->time);
30879   jresult = result;
30880   return jresult;
30881 }
30882
30883
30884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30885   void * jresult ;
30886   Dali::HoverEvent *result = 0 ;
30887
30888   {
30889     try {
30890       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30891     } catch (std::out_of_range& e) {
30892       {
30893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30894       };
30895     } catch (std::exception& e) {
30896       {
30897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30898       };
30899     } catch (Dali::DaliException e) {
30900       {
30901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30902       };
30903     } catch (...) {
30904       {
30905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30906       };
30907     }
30908   }
30909
30910   jresult = (void *)result;
30911   return jresult;
30912 }
30913
30914
30915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30916   void * jresult ;
30917   unsigned long arg1 ;
30918   Dali::HoverEvent *result = 0 ;
30919
30920   arg1 = (unsigned long)jarg1;
30921   {
30922     try {
30923       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30924     } catch (std::out_of_range& e) {
30925       {
30926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30927       };
30928     } catch (std::exception& e) {
30929       {
30930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30931       };
30932     } catch (Dali::DaliException e) {
30933       {
30934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30935       };
30936     } catch (...) {
30937       {
30938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30939       };
30940     }
30941   }
30942
30943   jresult = (void *)result;
30944   return jresult;
30945 }
30946
30947
30948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30949   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30950
30951   arg1 = (Dali::HoverEvent *)jarg1;
30952   {
30953     try {
30954       delete arg1;
30955     } catch (std::out_of_range& e) {
30956       {
30957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30958       };
30959     } catch (std::exception& e) {
30960       {
30961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30962       };
30963     } catch (Dali::DaliException e) {
30964       {
30965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30966       };
30967     } catch (...) {
30968       {
30969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30970       };
30971     }
30972   }
30973
30974 }
30975
30976
30977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30978   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30979   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30980
30981   arg1 = (Dali::HoverEvent *)jarg1;
30982   arg2 = (Dali::TouchPointContainer *)jarg2;
30983   if (arg1) (arg1)->points = *arg2;
30984 }
30985
30986
30987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30988   void * jresult ;
30989   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30990   Dali::TouchPointContainer *result = 0 ;
30991
30992   arg1 = (Dali::HoverEvent *)jarg1;
30993   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30994   jresult = (void *)result;
30995   return jresult;
30996 }
30997
30998
30999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
31000   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
31001   unsigned long arg2 ;
31002
31003   arg1 = (Dali::HoverEvent *)jarg1;
31004   arg2 = (unsigned long)jarg2;
31005   if (arg1) (arg1)->time = arg2;
31006 }
31007
31008
31009 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
31010   unsigned long jresult ;
31011   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
31012   unsigned long result;
31013
31014   arg1 = (Dali::HoverEvent *)jarg1;
31015   result = (unsigned long) ((arg1)->time);
31016   jresult = (unsigned long)result;
31017   return jresult;
31018 }
31019
31020
31021 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
31022   unsigned int jresult ;
31023   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
31024   unsigned int result;
31025
31026   arg1 = (Dali::HoverEvent *)jarg1;
31027   {
31028     try {
31029       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
31030     } catch (std::out_of_range& e) {
31031       {
31032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31033       };
31034     } catch (std::exception& e) {
31035       {
31036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31037       };
31038     } catch (Dali::DaliException e) {
31039       {
31040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31041       };
31042     } catch (...) {
31043       {
31044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31045       };
31046     }
31047   }
31048
31049   jresult = result;
31050   return jresult;
31051 }
31052
31053
31054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
31055   void * jresult ;
31056   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
31057   unsigned int arg2 ;
31058   Dali::TouchPoint *result = 0 ;
31059
31060   arg1 = (Dali::HoverEvent *)jarg1;
31061   arg2 = (unsigned int)jarg2;
31062   {
31063     try {
31064       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
31065     } catch (std::out_of_range& e) {
31066       {
31067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31068       };
31069     } catch (std::exception& e) {
31070       {
31071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31072       };
31073     } catch (Dali::DaliException e) {
31074       {
31075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31076       };
31077     } catch (...) {
31078       {
31079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31080       };
31081     }
31082   }
31083
31084   jresult = (void *)result;
31085   return jresult;
31086 }
31087
31088
31089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
31090   void * jresult ;
31091   Dali::KeyEvent *result = 0 ;
31092
31093   {
31094     try {
31095       result = (Dali::KeyEvent *)new Dali::KeyEvent();
31096     } catch (std::out_of_range& e) {
31097       {
31098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31099       };
31100     } catch (std::exception& e) {
31101       {
31102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31103       };
31104     } catch (Dali::DaliException e) {
31105       {
31106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31107       };
31108     } catch (...) {
31109       {
31110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31111       };
31112     }
31113   }
31114
31115   jresult = (void *)result;
31116   return jresult;
31117 }
31118
31119
31120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
31121   void * jresult ;
31122   std::string *arg1 = 0 ;
31123   std::string *arg2 = 0 ;
31124   int arg3 ;
31125   int arg4 ;
31126   unsigned long arg5 ;
31127   Dali::KeyEvent::State *arg6 = 0 ;
31128   Dali::KeyEvent::State temp6 ;
31129   Dali::KeyEvent *result = 0 ;
31130
31131   if (!jarg1) {
31132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31133     return 0;
31134   }
31135   std::string arg1_str(jarg1);
31136   arg1 = &arg1_str;
31137   if (!jarg2) {
31138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31139     return 0;
31140   }
31141   std::string arg2_str(jarg2);
31142   arg2 = &arg2_str;
31143   arg3 = (int)jarg3;
31144   arg4 = (int)jarg4;
31145   arg5 = (unsigned long)jarg5;
31146   temp6 = (Dali::KeyEvent::State)jarg6;
31147   arg6 = &temp6;
31148   {
31149     try {
31150       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
31151     } catch (std::out_of_range& e) {
31152       {
31153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31154       };
31155     } catch (std::exception& e) {
31156       {
31157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31158       };
31159     } catch (Dali::DaliException e) {
31160       {
31161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31162       };
31163     } catch (...) {
31164       {
31165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31166       };
31167     }
31168   }
31169
31170   jresult = (void *)result;
31171
31172   //argout typemap for const std::string&
31173
31174
31175   //argout typemap for const std::string&
31176
31177   return jresult;
31178 }
31179
31180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
31181   void * jresult ;
31182   Dali::KeyEvent *arg1 = 0 ;
31183   Dali::KeyEvent *result = 0 ;
31184
31185   arg1 = (Dali::KeyEvent *)jarg1;
31186   if (!arg1) {
31187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31188     return 0;
31189   }
31190   {
31191     try {
31192       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
31193     } catch (std::out_of_range& e) {
31194       {
31195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31196       };
31197     } catch (std::exception& e) {
31198       {
31199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31200       };
31201     } catch (Dali::DaliException e) {
31202       {
31203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31204       };
31205     } catch (...) {
31206       {
31207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31208       };
31209     }
31210   }
31211
31212   jresult = (void *)result;
31213   return jresult;
31214 }
31215
31216
31217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
31218   void * jresult ;
31219   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31220   Dali::KeyEvent *arg2 = 0 ;
31221   Dali::KeyEvent *result = 0 ;
31222
31223   arg1 = (Dali::KeyEvent *)jarg1;
31224   arg2 = (Dali::KeyEvent *)jarg2;
31225   if (!arg2) {
31226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31227     return 0;
31228   }
31229   {
31230     try {
31231       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31232     } catch (std::out_of_range& e) {
31233       {
31234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31235       };
31236     } catch (std::exception& e) {
31237       {
31238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31239       };
31240     } catch (Dali::DaliException e) {
31241       {
31242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31243       };
31244     } catch (...) {
31245       {
31246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31247       };
31248     }
31249   }
31250
31251   jresult = (void *)result;
31252   return jresult;
31253 }
31254
31255
31256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31257   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31258
31259   arg1 = (Dali::KeyEvent *)jarg1;
31260   {
31261     try {
31262       delete arg1;
31263     } catch (std::out_of_range& e) {
31264       {
31265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31266       };
31267     } catch (std::exception& e) {
31268       {
31269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31270       };
31271     } catch (Dali::DaliException e) {
31272       {
31273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31274       };
31275     } catch (...) {
31276       {
31277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31278       };
31279     }
31280   }
31281
31282 }
31283
31284
31285 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31286   unsigned int jresult ;
31287   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31288   bool result;
31289
31290   arg1 = (Dali::KeyEvent *)jarg1;
31291   {
31292     try {
31293       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
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 = result;
31314   return jresult;
31315 }
31316
31317
31318 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31319   unsigned int jresult ;
31320   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31321   bool result;
31322
31323   arg1 = (Dali::KeyEvent *)jarg1;
31324   {
31325     try {
31326       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
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 = result;
31347   return jresult;
31348 }
31349
31350
31351 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31352   unsigned int jresult ;
31353   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31354   bool result;
31355
31356   arg1 = (Dali::KeyEvent *)jarg1;
31357   {
31358     try {
31359       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31360     } catch (std::out_of_range& e) {
31361       {
31362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31363       };
31364     } catch (std::exception& e) {
31365       {
31366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31367       };
31368     } catch (Dali::DaliException e) {
31369       {
31370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31371       };
31372     } catch (...) {
31373       {
31374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31375       };
31376     }
31377   }
31378
31379   jresult = result;
31380   return jresult;
31381 }
31382
31383
31384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31385   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31386   std::string *arg2 = 0 ;
31387
31388   arg1 = (Dali::KeyEvent *)jarg1;
31389   if (!jarg2) {
31390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31391     return ;
31392   }
31393   std::string arg2_str(jarg2);
31394   arg2 = &arg2_str;
31395   if (arg1) (arg1)->keyPressedName = *arg2;
31396
31397   //argout typemap for const std::string&
31398
31399 }
31400
31401
31402 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31403   char * jresult ;
31404
31405   if( jarg1 == NULL )
31406   {
31407     jresult = SWIG_csharp_string_callback( "" );
31408   }
31409   else
31410   {
31411     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31412     std::string *result = 0;
31413
31414     arg1 = ( Dali::KeyEvent * )jarg1;
31415     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31416     jresult = SWIG_csharp_string_callback( result->c_str() );
31417   }
31418
31419   return jresult;
31420 }
31421
31422
31423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31424   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31425   std::string *arg2 = 0 ;
31426
31427   arg1 = (Dali::KeyEvent *)jarg1;
31428   if (!jarg2) {
31429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31430     return ;
31431   }
31432   std::string arg2_str(jarg2);
31433   arg2 = &arg2_str;
31434   if (arg1) (arg1)->keyPressed = *arg2;
31435
31436   //argout typemap for const std::string&
31437
31438 }
31439
31440
31441 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31442   char * jresult ;
31443   if( NULL == jarg1 )
31444   {
31445     jresult = SWIG_csharp_string_callback( "" );
31446   }
31447   else
31448   {
31449     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31450     std::string *result = 0;
31451
31452     arg1 = ( Dali::KeyEvent * )jarg1;
31453     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31454     jresult = SWIG_csharp_string_callback( result->c_str() );
31455   }
31456   return jresult;
31457 }
31458
31459
31460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31461   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31462   int arg2 ;
31463
31464   arg1 = (Dali::KeyEvent *)jarg1;
31465   arg2 = (int)jarg2;
31466   if (arg1) (arg1)->keyCode = arg2;
31467 }
31468
31469
31470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31471   int jresult ;
31472   if( NULL == jarg1 )
31473   {
31474     jresult = -1;
31475   }
31476   else
31477   {
31478     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31479     int result;
31480
31481     arg1 = ( Dali::KeyEvent * )jarg1;
31482     result = (int)( ( arg1 )->keyCode );
31483     jresult = result;
31484   }
31485   return jresult;
31486 }
31487
31488
31489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31490   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31491   int arg2 ;
31492
31493   arg1 = (Dali::KeyEvent *)jarg1;
31494   arg2 = (int)jarg2;
31495   if (arg1) (arg1)->keyModifier = arg2;
31496 }
31497
31498
31499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31500   int jresult ;
31501   if( jarg1 == NULL )
31502   {
31503     jresult = -1;
31504   }
31505   else
31506   {
31507     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31508     int result;
31509
31510     arg1 = ( Dali::KeyEvent * )jarg1;
31511     result = (int)( ( arg1 )->keyModifier );
31512     jresult = result;
31513   }
31514   return jresult;
31515 }
31516
31517
31518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31519   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31520   unsigned long arg2 ;
31521
31522   arg1 = (Dali::KeyEvent *)jarg1;
31523   arg2 = (unsigned long)jarg2;
31524   if (arg1) (arg1)->time = arg2;
31525 }
31526
31527
31528 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31529   unsigned long jresult ;
31530   if( jarg1 == NULL )
31531   {
31532     jresult = 0;
31533   }
31534   else
31535   {
31536     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31537     unsigned long result;
31538
31539     arg1 = ( Dali::KeyEvent * )jarg1;
31540     result = (unsigned long)( ( arg1 )->time );
31541     jresult = (unsigned long)result;
31542   }
31543   return jresult;
31544 }
31545
31546
31547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31548   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31549   Dali::KeyEvent::State arg2 ;
31550
31551   arg1 = (Dali::KeyEvent *)jarg1;
31552   arg2 = (Dali::KeyEvent::State)jarg2;
31553   if (arg1) (arg1)->state = arg2;
31554 }
31555
31556
31557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31558   int jresult ;
31559   if( jarg1 == NULL )
31560   {
31561     jresult = -1;
31562   }
31563   else
31564   {
31565     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31566     Dali::KeyEvent::State result;
31567
31568     arg1 = ( Dali::KeyEvent * )jarg1;
31569     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31570     jresult = (int)result;
31571   }
31572   return jresult;
31573 }
31574
31575 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
31576   char * jresult ;
31577   std::string result;
31578   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0;
31579
31580   arg1 = (Dali::KeyEvent *)jarg1;
31581   if (!arg1) {
31582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::DevelKeyEvent const & type is null", 0);
31583     return 0;
31584   }
31585   {
31586     try {
31587       result = Dali::DevelKeyEvent::GetLogicalKey(*arg1);
31588     } catch (std::out_of_range& e) {
31589       {
31590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31591       };
31592     } catch (std::exception& e) {
31593       {
31594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31595       };
31596     } catch (Dali::DaliException e) {
31597       {
31598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31599       };
31600     } catch (...) {
31601       {
31602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31603       };
31604     }
31605
31606   }
31607
31608   jresult = SWIG_csharp_string_callback( (&result)->c_str() );
31609   return jresult;
31610 }
31611
31612
31613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31614   void * jresult ;
31615   Dali::LongPressGestureDetector *result = 0 ;
31616
31617   {
31618     try {
31619       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31620     } catch (std::out_of_range& e) {
31621       {
31622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31623       };
31624     } catch (std::exception& e) {
31625       {
31626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31627       };
31628     } catch (Dali::DaliException e) {
31629       {
31630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31631       };
31632     } catch (...) {
31633       {
31634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31635       };
31636     }
31637   }
31638
31639   jresult = (void *)result;
31640   return jresult;
31641 }
31642
31643
31644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31645   void * jresult ;
31646   Dali::LongPressGestureDetector result;
31647
31648   {
31649     try {
31650       result = Dali::LongPressGestureDetector::New();
31651     } catch (std::out_of_range& e) {
31652       {
31653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31654       };
31655     } catch (std::exception& e) {
31656       {
31657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31658       };
31659     } catch (Dali::DaliException e) {
31660       {
31661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31662       };
31663     } catch (...) {
31664       {
31665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31666       };
31667     }
31668   }
31669
31670   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31671   return jresult;
31672 }
31673
31674
31675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31676   void * jresult ;
31677   unsigned int arg1 ;
31678   Dali::LongPressGestureDetector result;
31679
31680   arg1 = (unsigned int)jarg1;
31681   {
31682     try {
31683       result = Dali::LongPressGestureDetector::New(arg1);
31684     } catch (std::out_of_range& e) {
31685       {
31686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31687       };
31688     } catch (std::exception& e) {
31689       {
31690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31691       };
31692     } catch (Dali::DaliException e) {
31693       {
31694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31695       };
31696     } catch (...) {
31697       {
31698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31699       };
31700     }
31701   }
31702
31703   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31704   return jresult;
31705 }
31706
31707
31708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31709   void * jresult ;
31710   unsigned int arg1 ;
31711   unsigned int arg2 ;
31712   Dali::LongPressGestureDetector result;
31713
31714   arg1 = (unsigned int)jarg1;
31715   arg2 = (unsigned int)jarg2;
31716   {
31717     try {
31718       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31719     } catch (std::out_of_range& e) {
31720       {
31721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31722       };
31723     } catch (std::exception& e) {
31724       {
31725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31726       };
31727     } catch (Dali::DaliException e) {
31728       {
31729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31730       };
31731     } catch (...) {
31732       {
31733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31734       };
31735     }
31736   }
31737
31738   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31739   return jresult;
31740 }
31741
31742
31743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31744   void * jresult ;
31745   Dali::BaseHandle arg1 ;
31746   Dali::BaseHandle *argp1 ;
31747   Dali::LongPressGestureDetector result;
31748
31749   argp1 = (Dali::BaseHandle *)jarg1;
31750   if (!argp1) {
31751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31752     return 0;
31753   }
31754   arg1 = *argp1;
31755   {
31756     try {
31757       result = Dali::LongPressGestureDetector::DownCast(arg1);
31758     } catch (std::out_of_range& e) {
31759       {
31760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31761       };
31762     } catch (std::exception& e) {
31763       {
31764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31765       };
31766     } catch (Dali::DaliException e) {
31767       {
31768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31769       };
31770     } catch (...) {
31771       {
31772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31773       };
31774     }
31775   }
31776
31777   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31778   return jresult;
31779 }
31780
31781
31782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31783   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31784
31785   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31786   {
31787     try {
31788       delete arg1;
31789     } catch (std::out_of_range& e) {
31790       {
31791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31792       };
31793     } catch (std::exception& e) {
31794       {
31795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31796       };
31797     } catch (Dali::DaliException e) {
31798       {
31799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31800       };
31801     } catch (...) {
31802       {
31803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31804       };
31805     }
31806   }
31807
31808 }
31809
31810
31811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31812   void * jresult ;
31813   Dali::LongPressGestureDetector *arg1 = 0 ;
31814   Dali::LongPressGestureDetector *result = 0 ;
31815
31816   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31817   if (!arg1) {
31818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31819     return 0;
31820   }
31821   {
31822     try {
31823       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31824     } catch (std::out_of_range& e) {
31825       {
31826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31827       };
31828     } catch (std::exception& e) {
31829       {
31830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31831       };
31832     } catch (Dali::DaliException e) {
31833       {
31834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31835       };
31836     } catch (...) {
31837       {
31838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31839       };
31840     }
31841   }
31842
31843   jresult = (void *)result;
31844   return jresult;
31845 }
31846
31847
31848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31849   void * jresult ;
31850   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31851   Dali::LongPressGestureDetector *arg2 = 0 ;
31852   Dali::LongPressGestureDetector *result = 0 ;
31853
31854   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31855   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31856   if (!arg2) {
31857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31858     return 0;
31859   }
31860   {
31861     try {
31862       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31863     } catch (std::out_of_range& e) {
31864       {
31865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31866       };
31867     } catch (std::exception& e) {
31868       {
31869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31870       };
31871     } catch (Dali::DaliException e) {
31872       {
31873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31874       };
31875     } catch (...) {
31876       {
31877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31878       };
31879     }
31880   }
31881
31882   jresult = (void *)result;
31883   return jresult;
31884 }
31885
31886
31887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31888   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31889   unsigned int arg2 ;
31890
31891   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31892   arg2 = (unsigned int)jarg2;
31893   {
31894     try {
31895       (arg1)->SetTouchesRequired(arg2);
31896     } catch (std::out_of_range& e) {
31897       {
31898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31899       };
31900     } catch (std::exception& e) {
31901       {
31902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31903       };
31904     } catch (Dali::DaliException e) {
31905       {
31906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31907       };
31908     } catch (...) {
31909       {
31910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31911       };
31912     }
31913   }
31914
31915 }
31916
31917
31918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31919   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31920   unsigned int arg2 ;
31921   unsigned int arg3 ;
31922
31923   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31924   arg2 = (unsigned int)jarg2;
31925   arg3 = (unsigned int)jarg3;
31926   {
31927     try {
31928       (arg1)->SetTouchesRequired(arg2,arg3);
31929     } catch (std::out_of_range& e) {
31930       {
31931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31932       };
31933     } catch (std::exception& e) {
31934       {
31935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31936       };
31937     } catch (Dali::DaliException e) {
31938       {
31939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31940       };
31941     } catch (...) {
31942       {
31943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31944       };
31945     }
31946   }
31947
31948 }
31949
31950
31951 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31952   unsigned int jresult ;
31953   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31954   unsigned int result;
31955
31956   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31957   {
31958     try {
31959       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31960     } catch (std::out_of_range& e) {
31961       {
31962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31963       };
31964     } catch (std::exception& e) {
31965       {
31966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31967       };
31968     } catch (Dali::DaliException e) {
31969       {
31970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31971       };
31972     } catch (...) {
31973       {
31974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31975       };
31976     }
31977   }
31978
31979   jresult = result;
31980   return jresult;
31981 }
31982
31983
31984 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31985   unsigned int jresult ;
31986   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31987   unsigned int result;
31988
31989   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31990   {
31991     try {
31992       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31993     } catch (std::out_of_range& e) {
31994       {
31995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31996       };
31997     } catch (std::exception& e) {
31998       {
31999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32000       };
32001     } catch (Dali::DaliException e) {
32002       {
32003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32004       };
32005     } catch (...) {
32006       {
32007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32008       };
32009     }
32010   }
32011
32012   jresult = result;
32013   return jresult;
32014 }
32015
32016
32017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
32018   void * jresult ;
32019   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
32020   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
32021
32022   arg1 = (Dali::LongPressGestureDetector *)jarg1;
32023   {
32024     try {
32025       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
32026     } catch (std::out_of_range& e) {
32027       {
32028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32029       };
32030     } catch (std::exception& e) {
32031       {
32032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32033       };
32034     } catch (Dali::DaliException e) {
32035       {
32036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32037       };
32038     } catch (...) {
32039       {
32040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32041       };
32042     }
32043   }
32044
32045   jresult = (void *)result;
32046   return jresult;
32047 }
32048
32049
32050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
32051   void * jresult ;
32052   Dali::Gesture::State arg1 ;
32053   Dali::LongPressGesture *result = 0 ;
32054
32055   arg1 = (Dali::Gesture::State)jarg1;
32056   {
32057     try {
32058       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
32059     } catch (std::out_of_range& e) {
32060       {
32061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32062       };
32063     } catch (std::exception& e) {
32064       {
32065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32066       };
32067     } catch (Dali::DaliException e) {
32068       {
32069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32070       };
32071     } catch (...) {
32072       {
32073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32074       };
32075     }
32076   }
32077
32078   jresult = (void *)result;
32079   return jresult;
32080 }
32081
32082
32083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
32084   void * jresult ;
32085   Dali::LongPressGesture *arg1 = 0 ;
32086   Dali::LongPressGesture *result = 0 ;
32087
32088   arg1 = (Dali::LongPressGesture *)jarg1;
32089   if (!arg1) {
32090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
32091     return 0;
32092   }
32093   {
32094     try {
32095       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
32096     } catch (std::out_of_range& e) {
32097       {
32098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32099       };
32100     } catch (std::exception& e) {
32101       {
32102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32103       };
32104     } catch (Dali::DaliException e) {
32105       {
32106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32107       };
32108     } catch (...) {
32109       {
32110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32111       };
32112     }
32113   }
32114
32115   jresult = (void *)result;
32116   return jresult;
32117 }
32118
32119
32120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
32121   void * jresult ;
32122   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32123   Dali::LongPressGesture *arg2 = 0 ;
32124   Dali::LongPressGesture *result = 0 ;
32125
32126   arg1 = (Dali::LongPressGesture *)jarg1;
32127   arg2 = (Dali::LongPressGesture *)jarg2;
32128   if (!arg2) {
32129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
32130     return 0;
32131   }
32132   {
32133     try {
32134       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
32135     } catch (std::out_of_range& e) {
32136       {
32137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32138       };
32139     } catch (std::exception& e) {
32140       {
32141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32142       };
32143     } catch (Dali::DaliException e) {
32144       {
32145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32146       };
32147     } catch (...) {
32148       {
32149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32150       };
32151     }
32152   }
32153
32154   jresult = (void *)result;
32155   return jresult;
32156 }
32157
32158
32159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
32160   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32161
32162   arg1 = (Dali::LongPressGesture *)jarg1;
32163   {
32164     try {
32165       delete arg1;
32166     } catch (std::out_of_range& e) {
32167       {
32168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32169       };
32170     } catch (std::exception& e) {
32171       {
32172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32173       };
32174     } catch (Dali::DaliException e) {
32175       {
32176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32177       };
32178     } catch (...) {
32179       {
32180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32181       };
32182     }
32183   }
32184
32185 }
32186
32187
32188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
32189   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32190   unsigned int arg2 ;
32191
32192   arg1 = (Dali::LongPressGesture *)jarg1;
32193   arg2 = (unsigned int)jarg2;
32194   if (arg1) (arg1)->numberOfTouches = arg2;
32195 }
32196
32197
32198 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
32199   unsigned int jresult ;
32200   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32201   unsigned int result;
32202
32203   arg1 = (Dali::LongPressGesture *)jarg1;
32204   result = (unsigned int) ((arg1)->numberOfTouches);
32205   jresult = result;
32206   return jresult;
32207 }
32208
32209
32210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
32211   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32212   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32213
32214   arg1 = (Dali::LongPressGesture *)jarg1;
32215   arg2 = (Dali::Vector2 *)jarg2;
32216   if (arg1) (arg1)->screenPoint = *arg2;
32217 }
32218
32219
32220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
32221   void * jresult ;
32222   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32223   Dali::Vector2 *result = 0 ;
32224
32225   arg1 = (Dali::LongPressGesture *)jarg1;
32226   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
32227   jresult = (void *)result;
32228   return jresult;
32229 }
32230
32231
32232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
32233   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32234   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32235
32236   arg1 = (Dali::LongPressGesture *)jarg1;
32237   arg2 = (Dali::Vector2 *)jarg2;
32238   if (arg1) (arg1)->localPoint = *arg2;
32239 }
32240
32241
32242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
32243   void * jresult ;
32244   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32245   Dali::Vector2 *result = 0 ;
32246
32247   arg1 = (Dali::LongPressGesture *)jarg1;
32248   result = (Dali::Vector2 *)& ((arg1)->localPoint);
32249   jresult = (void *)result;
32250   return jresult;
32251 }
32252
32253
32254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
32255   void * jresult ;
32256   Dali::WheelEvent *result = 0 ;
32257
32258   {
32259     try {
32260       result = (Dali::WheelEvent *)new Dali::WheelEvent();
32261     } catch (std::out_of_range& e) {
32262       {
32263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32264       };
32265     } catch (std::exception& e) {
32266       {
32267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32268       };
32269     } catch (Dali::DaliException e) {
32270       {
32271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32272       };
32273     } catch (...) {
32274       {
32275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32276       };
32277     }
32278   }
32279
32280   jresult = (void *)result;
32281   return jresult;
32282 }
32283
32284
32285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
32286   void * jresult ;
32287   Dali::WheelEvent::Type arg1 ;
32288   int arg2 ;
32289   unsigned int arg3 ;
32290   Dali::Vector2 arg4 ;
32291   int arg5 ;
32292   unsigned int arg6 ;
32293   Dali::Vector2 *argp4 ;
32294   Dali::WheelEvent *result = 0 ;
32295
32296   arg1 = (Dali::WheelEvent::Type)jarg1;
32297   arg2 = (int)jarg2;
32298   arg3 = (unsigned int)jarg3;
32299   argp4 = (Dali::Vector2 *)jarg4;
32300   if (!argp4) {
32301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32302     return 0;
32303   }
32304   arg4 = *argp4;
32305   arg5 = (int)jarg5;
32306   arg6 = (unsigned int)jarg6;
32307   {
32308     try {
32309       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
32310     } catch (std::out_of_range& e) {
32311       {
32312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32313       };
32314     } catch (std::exception& e) {
32315       {
32316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32317       };
32318     } catch (Dali::DaliException e) {
32319       {
32320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32321       };
32322     } catch (...) {
32323       {
32324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32325       };
32326     }
32327   }
32328
32329   jresult = (void *)result;
32330   return jresult;
32331 }
32332
32333
32334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32335   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32336
32337   arg1 = (Dali::WheelEvent *)jarg1;
32338   {
32339     try {
32340       delete arg1;
32341     } catch (std::out_of_range& e) {
32342       {
32343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32344       };
32345     } catch (std::exception& e) {
32346       {
32347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32348       };
32349     } catch (Dali::DaliException e) {
32350       {
32351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32352       };
32353     } catch (...) {
32354       {
32355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32356       };
32357     }
32358   }
32359
32360 }
32361
32362
32363 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32364   unsigned int jresult ;
32365   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32366   bool result;
32367
32368   arg1 = (Dali::WheelEvent *)jarg1;
32369   {
32370     try {
32371       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32372     } catch (std::out_of_range& e) {
32373       {
32374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32375       };
32376     } catch (std::exception& e) {
32377       {
32378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32379       };
32380     } catch (Dali::DaliException e) {
32381       {
32382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32383       };
32384     } catch (...) {
32385       {
32386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32387       };
32388     }
32389   }
32390
32391   jresult = result;
32392   return jresult;
32393 }
32394
32395
32396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32397   unsigned int jresult ;
32398   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32399   bool result;
32400
32401   arg1 = (Dali::WheelEvent *)jarg1;
32402   {
32403     try {
32404       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32405     } catch (std::out_of_range& e) {
32406       {
32407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32408       };
32409     } catch (std::exception& e) {
32410       {
32411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32412       };
32413     } catch (Dali::DaliException e) {
32414       {
32415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32416       };
32417     } catch (...) {
32418       {
32419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32420       };
32421     }
32422   }
32423
32424   jresult = result;
32425   return jresult;
32426 }
32427
32428
32429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32430   unsigned int jresult ;
32431   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32432   bool result;
32433
32434   arg1 = (Dali::WheelEvent *)jarg1;
32435   {
32436     try {
32437       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32438     } catch (std::out_of_range& e) {
32439       {
32440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32441       };
32442     } catch (std::exception& e) {
32443       {
32444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32445       };
32446     } catch (Dali::DaliException e) {
32447       {
32448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32449       };
32450     } catch (...) {
32451       {
32452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32453       };
32454     }
32455   }
32456
32457   jresult = result;
32458   return jresult;
32459 }
32460
32461
32462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32463   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32464   Dali::WheelEvent::Type arg2 ;
32465
32466   arg1 = (Dali::WheelEvent *)jarg1;
32467   arg2 = (Dali::WheelEvent::Type)jarg2;
32468   if (arg1) (arg1)->type = arg2;
32469 }
32470
32471
32472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32473   int jresult ;
32474   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32475   Dali::WheelEvent::Type result;
32476
32477   arg1 = (Dali::WheelEvent *)jarg1;
32478   result = (Dali::WheelEvent::Type) ((arg1)->type);
32479   jresult = (int)result;
32480   return jresult;
32481 }
32482
32483
32484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32485   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32486   int arg2 ;
32487
32488   arg1 = (Dali::WheelEvent *)jarg1;
32489   arg2 = (int)jarg2;
32490   if (arg1) (arg1)->direction = arg2;
32491 }
32492
32493
32494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32495   int jresult ;
32496   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32497   int result;
32498
32499   arg1 = (Dali::WheelEvent *)jarg1;
32500   result = (int) ((arg1)->direction);
32501   jresult = result;
32502   return jresult;
32503 }
32504
32505
32506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32507   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32508   unsigned int arg2 ;
32509
32510   arg1 = (Dali::WheelEvent *)jarg1;
32511   arg2 = (unsigned int)jarg2;
32512   if (arg1) (arg1)->modifiers = arg2;
32513 }
32514
32515
32516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32517   unsigned int jresult ;
32518   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32519   unsigned int result;
32520
32521   arg1 = (Dali::WheelEvent *)jarg1;
32522   result = (unsigned int) ((arg1)->modifiers);
32523   jresult = result;
32524   return jresult;
32525 }
32526
32527
32528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32529   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32530   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32531
32532   arg1 = (Dali::WheelEvent *)jarg1;
32533   arg2 = (Dali::Vector2 *)jarg2;
32534   if (arg1) (arg1)->point = *arg2;
32535 }
32536
32537
32538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32539   void * jresult ;
32540   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32541   Dali::Vector2 *result = 0 ;
32542
32543   arg1 = (Dali::WheelEvent *)jarg1;
32544   result = (Dali::Vector2 *)& ((arg1)->point);
32545   jresult = (void *)result;
32546   return jresult;
32547 }
32548
32549
32550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32551   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32552   int arg2 ;
32553
32554   arg1 = (Dali::WheelEvent *)jarg1;
32555   arg2 = (int)jarg2;
32556   if (arg1) (arg1)->z = arg2;
32557 }
32558
32559
32560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32561   int jresult ;
32562   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32563   int result;
32564
32565   arg1 = (Dali::WheelEvent *)jarg1;
32566   result = (int) ((arg1)->z);
32567   jresult = result;
32568   return jresult;
32569 }
32570
32571
32572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32573   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32574   unsigned int arg2 ;
32575
32576   arg1 = (Dali::WheelEvent *)jarg1;
32577   arg2 = (unsigned int)jarg2;
32578   if (arg1) (arg1)->timeStamp = arg2;
32579 }
32580
32581
32582 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32583   unsigned int jresult ;
32584   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32585   unsigned int result;
32586
32587   arg1 = (Dali::WheelEvent *)jarg1;
32588   result = (unsigned int) ((arg1)->timeStamp);
32589   jresult = result;
32590   return jresult;
32591 }
32592
32593 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32594   char * jresult ;
32595   Dali::KeyEvent *arg1 = 0 ;
32596   std::string result;
32597
32598   arg1 = (Dali::KeyEvent *)jarg1;
32599   if (!arg1) {
32600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32601     return 0;
32602   }
32603   {
32604     try {
32605       result = arg1->GetDeviceName();
32606     } catch (std::out_of_range& e) {
32607       {
32608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32609       };
32610     } catch (std::exception& e) {
32611       {
32612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32613       };
32614     } catch (Dali::DaliException e) {
32615       {
32616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32617       };
32618     } catch (...) {
32619       {
32620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32621       };
32622     }
32623   }
32624
32625   jresult = SWIG_csharp_string_callback((&result)->c_str());
32626   return jresult;
32627 }
32628
32629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32630   int jresult ;
32631   Dali::KeyEvent *arg1 = 0 ;
32632   Dali::Device::Class::Type result;
32633
32634   arg1 = (Dali::KeyEvent *)jarg1;
32635   if (!arg1) {
32636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32637     return 0;
32638   }
32639   {
32640     try {
32641       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32642     } catch (std::out_of_range& e) {
32643       {
32644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32645       };
32646     } catch (std::exception& e) {
32647       {
32648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32649       };
32650     } catch (Dali::DaliException e) {
32651       {
32652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32653       };
32654     } catch (...) {
32655       {
32656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32657       };
32658     }
32659   }
32660
32661   jresult = (int)result;
32662   return jresult;
32663 }
32664
32665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32666   int jresult ;
32667   Dali::KeyEvent *arg1 = 0 ;
32668   Dali::Device::Subclass::Type result;
32669
32670   arg1 = (Dali::KeyEvent *)jarg1;
32671   if (!arg1) {
32672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32673     return 0;
32674   }
32675   {
32676     try {
32677       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32678     } catch (std::out_of_range& e) {
32679       {
32680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32681       };
32682     } catch (std::exception& e) {
32683       {
32684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32685       };
32686     } catch (Dali::DaliException e) {
32687       {
32688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32689       };
32690     } catch (...) {
32691       {
32692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32693       };
32694     }
32695   }
32696
32697   jresult = (int)result;
32698   return jresult;
32699 }
32700
32701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32702   Dali::Actor arg1 ;
32703   Dali::Actor *argp1 ;
32704
32705   argp1 = (Dali::Actor *)jarg1;
32706   if (!argp1) {
32707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32708     return ;
32709   }
32710   arg1 = *argp1;
32711   {
32712     try {
32713       arg1.Raise();
32714     } catch (std::out_of_range& e) {
32715       {
32716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32717       };
32718     } catch (std::exception& e) {
32719       {
32720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32721       };
32722     } catch (Dali::DaliException e) {
32723       {
32724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32725       };
32726     } catch (...) {
32727       {
32728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32729       };
32730     }
32731   }
32732
32733 }
32734
32735
32736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32737   Dali::Actor arg1 ;
32738   Dali::Actor *argp1 ;
32739
32740   argp1 = (Dali::Actor *)jarg1;
32741   if (!argp1) {
32742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32743     return ;
32744   }
32745   arg1 = *argp1;
32746   {
32747     try {
32748       arg1.Lower();
32749     } catch (std::out_of_range& e) {
32750       {
32751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32752       };
32753     } catch (std::exception& e) {
32754       {
32755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32756       };
32757     } catch (Dali::DaliException e) {
32758       {
32759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32760       };
32761     } catch (...) {
32762       {
32763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32764       };
32765     }
32766   }
32767
32768 }
32769
32770
32771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32772   Dali::Actor arg1 ;
32773   Dali::Actor *argp1 ;
32774
32775   argp1 = (Dali::Actor *)jarg1;
32776   if (!argp1) {
32777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32778     return ;
32779   }
32780   arg1 = *argp1;
32781   {
32782     try {
32783       arg1.RaiseToTop();
32784     } catch (std::out_of_range& e) {
32785       {
32786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32787       };
32788     } catch (std::exception& e) {
32789       {
32790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32791       };
32792     } catch (Dali::DaliException e) {
32793       {
32794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32795       };
32796     } catch (...) {
32797       {
32798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32799       };
32800     }
32801   }
32802
32803 }
32804
32805
32806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32807   Dali::Actor arg1 ;
32808   Dali::Actor *argp1 ;
32809
32810   argp1 = (Dali::Actor *)jarg1;
32811   if (!argp1) {
32812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32813     return ;
32814   }
32815   arg1 = *argp1;
32816   {
32817     try {
32818       arg1.LowerToBottom();
32819     } catch (std::out_of_range& e) {
32820       {
32821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32822       };
32823     } catch (std::exception& e) {
32824       {
32825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32826       };
32827     } catch (Dali::DaliException e) {
32828       {
32829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32830       };
32831     } catch (...) {
32832       {
32833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32834       };
32835     }
32836   }
32837
32838 }
32839
32840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32841   Dali::Actor arg1 ;
32842   Dali::Actor arg2 ;
32843   Dali::Actor *argp1 ;
32844   Dali::Actor *argp2 ;
32845
32846   argp1 = (Dali::Actor *)jarg1;
32847   if (!argp1) {
32848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32849     return ;
32850   }
32851   arg1 = *argp1;
32852   argp2 = (Dali::Actor *)jarg2;
32853   if (!argp2) {
32854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32855     return ;
32856   }
32857   arg2 = *argp2;
32858   {
32859     try {
32860       arg1.RaiseAbove(arg2);
32861     } catch (std::out_of_range& e) {
32862       {
32863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32864       };
32865     } catch (std::exception& e) {
32866       {
32867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32868       };
32869     } catch (Dali::DaliException e) {
32870       {
32871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32872       };
32873     } catch (...) {
32874       {
32875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32876       };
32877     }
32878   }
32879
32880 }
32881
32882
32883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32884   Dali::Actor arg1 ;
32885   Dali::Actor arg2 ;
32886   Dali::Actor *argp1 ;
32887   Dali::Actor *argp2 ;
32888
32889   argp1 = (Dali::Actor *)jarg1;
32890   if (!argp1) {
32891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32892     return ;
32893   }
32894   arg1 = *argp1;
32895   argp2 = (Dali::Actor *)jarg2;
32896   if (!argp2) {
32897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32898     return ;
32899   }
32900   arg2 = *argp2;
32901   {
32902     try {
32903       arg1.LowerBelow(arg2);
32904     } catch (std::out_of_range& e) {
32905       {
32906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32907       };
32908     } catch (std::exception& e) {
32909       {
32910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32911       };
32912     } catch (Dali::DaliException e) {
32913       {
32914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32915       };
32916     } catch (...) {
32917       {
32918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32919       };
32920     }
32921   }
32922
32923 }
32924
32925
32926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32927   void * jresult ;
32928   Dali::Actor arg1 ;
32929   Dali::Actor *argp1 ;
32930   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32931
32932   argp1 = (Dali::Actor *)jarg1;
32933   if (!argp1) {
32934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32935     return 0;
32936   }
32937   arg1 = *argp1;
32938   {
32939     try {
32940       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32941     } catch (std::out_of_range& e) {
32942       {
32943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32944       };
32945     } catch (std::exception& e) {
32946       {
32947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32948       };
32949     } catch (Dali::DaliException e) {
32950       {
32951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32952       };
32953     } catch (...) {
32954       {
32955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32956       };
32957     }
32958   }
32959
32960   jresult = (void *)result;
32961   return jresult;
32962 }
32963
32964
32965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32966   void * jresult ;
32967   Dali::Actor *arg1 ;
32968   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32969
32970   arg1 = (Dali::Actor *)jarg1;
32971   {
32972     try {
32973       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32974     } catch (std::out_of_range& e) {
32975       {
32976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32977       };
32978     } catch (std::exception& e) {
32979       {
32980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32981       };
32982     } catch (Dali::DaliException e) {
32983       {
32984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32985       };
32986     } catch (...) {
32987       {
32988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32989       };
32990     }
32991   }
32992
32993   jresult = (void *)result;
32994   return jresult;
32995 }
32996
32997
32998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32999   int jresult ;
33000   int result;
33001
33002   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
33003   jresult = (int)result;
33004   return jresult;
33005 }
33006
33007
33008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
33009   int jresult ;
33010   int result;
33011
33012   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
33013   jresult = (int)result;
33014   return jresult;
33015 }
33016
33017
33018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
33019   int jresult ;
33020   int result;
33021
33022   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
33023   jresult = (int)result;
33024   return jresult;
33025 }
33026
33027
33028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
33029   int jresult ;
33030   int result;
33031
33032   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
33033   jresult = (int)result;
33034   return jresult;
33035 }
33036
33037
33038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
33039   int jresult ;
33040   int result;
33041
33042   result = (int)Dali::Actor::Property::ANCHOR_POINT;
33043   jresult = (int)result;
33044   return jresult;
33045 }
33046
33047
33048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
33049   int jresult ;
33050   int result;
33051
33052   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
33053   jresult = (int)result;
33054   return jresult;
33055 }
33056
33057
33058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
33059   int jresult ;
33060   int result;
33061
33062   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
33063   jresult = (int)result;
33064   return jresult;
33065 }
33066
33067
33068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
33069   int jresult ;
33070   int result;
33071
33072   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
33073   jresult = (int)result;
33074   return jresult;
33075 }
33076
33077
33078 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
33079   int jresult ;
33080   int result;
33081
33082   result = (int)Dali::Actor::Property::SIZE;
33083   jresult = (int)result;
33084   return jresult;
33085 }
33086
33087
33088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
33089   int jresult ;
33090   int result;
33091
33092   result = (int)Dali::Actor::Property::SIZE_WIDTH;
33093   jresult = (int)result;
33094   return jresult;
33095 }
33096
33097
33098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
33099   int jresult ;
33100   int result;
33101
33102   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
33103   jresult = (int)result;
33104   return jresult;
33105 }
33106
33107
33108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
33109   int jresult ;
33110   int result;
33111
33112   result = (int)Dali::Actor::Property::SIZE_DEPTH;
33113   jresult = (int)result;
33114   return jresult;
33115 }
33116
33117
33118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
33119   int jresult ;
33120   int result;
33121
33122   result = (int)Dali::Actor::Property::POSITION;
33123   jresult = (int)result;
33124   return jresult;
33125 }
33126
33127
33128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
33129   int jresult ;
33130   int result;
33131
33132   result = (int)Dali::Actor::Property::POSITION_X;
33133   jresult = (int)result;
33134   return jresult;
33135 }
33136
33137
33138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
33139   int jresult ;
33140   int result;
33141
33142   result = (int)Dali::Actor::Property::POSITION_Y;
33143   jresult = (int)result;
33144   return jresult;
33145 }
33146
33147
33148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
33149   int jresult ;
33150   int result;
33151
33152   result = (int)Dali::Actor::Property::POSITION_Z;
33153   jresult = (int)result;
33154   return jresult;
33155 }
33156
33157
33158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
33159   int jresult ;
33160   int result;
33161
33162   result = (int)Dali::Actor::Property::WORLD_POSITION;
33163   jresult = (int)result;
33164   return jresult;
33165 }
33166
33167
33168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
33169   int jresult ;
33170   int result;
33171
33172   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
33173   jresult = (int)result;
33174   return jresult;
33175 }
33176
33177
33178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
33179   int jresult ;
33180   int result;
33181
33182   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
33183   jresult = (int)result;
33184   return jresult;
33185 }
33186
33187
33188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
33189   int jresult ;
33190   int result;
33191
33192   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
33193   jresult = (int)result;
33194   return jresult;
33195 }
33196
33197
33198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
33199   int jresult ;
33200   int result;
33201
33202   result = (int)Dali::Actor::Property::ORIENTATION;
33203   jresult = (int)result;
33204   return jresult;
33205 }
33206
33207
33208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
33209   int jresult ;
33210   int result;
33211
33212   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
33213   jresult = (int)result;
33214   return jresult;
33215 }
33216
33217
33218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
33219   int jresult ;
33220   int result;
33221
33222   result = (int)Dali::Actor::Property::SCALE;
33223   jresult = (int)result;
33224   return jresult;
33225 }
33226
33227
33228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
33229   int jresult ;
33230   int result;
33231
33232   result = (int)Dali::Actor::Property::SCALE_X;
33233   jresult = (int)result;
33234   return jresult;
33235 }
33236
33237
33238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
33239   int jresult ;
33240   int result;
33241
33242   result = (int)Dali::Actor::Property::SCALE_Y;
33243   jresult = (int)result;
33244   return jresult;
33245 }
33246
33247
33248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
33249   int jresult ;
33250   int result;
33251
33252   result = (int)Dali::Actor::Property::SCALE_Z;
33253   jresult = (int)result;
33254   return jresult;
33255 }
33256
33257
33258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
33259   int jresult ;
33260   int result;
33261
33262   result = (int)Dali::Actor::Property::WORLD_SCALE;
33263   jresult = (int)result;
33264   return jresult;
33265 }
33266
33267
33268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
33269   int jresult ;
33270   int result;
33271
33272   result = (int)Dali::Actor::Property::VISIBLE;
33273   jresult = (int)result;
33274   return jresult;
33275 }
33276
33277
33278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
33279   int jresult ;
33280   int result;
33281
33282   result = (int)Dali::Actor::Property::COLOR;
33283   jresult = (int)result;
33284   return jresult;
33285 }
33286
33287
33288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33289   int jresult ;
33290   int result;
33291
33292   result = (int)Dali::Actor::Property::COLOR_RED;
33293   jresult = (int)result;
33294   return jresult;
33295 }
33296
33297
33298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33299   int jresult ;
33300   int result;
33301
33302   result = (int)Dali::Actor::Property::COLOR_GREEN;
33303   jresult = (int)result;
33304   return jresult;
33305 }
33306
33307
33308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33309   int jresult ;
33310   int result;
33311
33312   result = (int)Dali::Actor::Property::COLOR_BLUE;
33313   jresult = (int)result;
33314   return jresult;
33315 }
33316
33317
33318 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33319   int jresult ;
33320   int result;
33321
33322   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33323   jresult = (int)result;
33324   return jresult;
33325 }
33326
33327
33328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33329   int jresult ;
33330   int result;
33331
33332   result = (int)Dali::Actor::Property::WORLD_COLOR;
33333   jresult = (int)result;
33334   return jresult;
33335 }
33336
33337
33338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33339   int jresult ;
33340   int result;
33341
33342   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33343   jresult = (int)result;
33344   return jresult;
33345 }
33346
33347
33348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33349   int jresult ;
33350   int result;
33351
33352   result = (int)Dali::Actor::Property::NAME;
33353   jresult = (int)result;
33354   return jresult;
33355 }
33356
33357
33358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33359   int jresult ;
33360   int result;
33361
33362   result = (int)Dali::Actor::Property::SENSITIVE;
33363   jresult = (int)result;
33364   return jresult;
33365 }
33366
33367
33368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33369   int jresult ;
33370   int result;
33371
33372   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33373   jresult = (int)result;
33374   return jresult;
33375 }
33376
33377
33378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33379   int jresult ;
33380   int result;
33381
33382   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33383   jresult = (int)result;
33384   return jresult;
33385 }
33386
33387
33388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33389   int jresult ;
33390   int result;
33391
33392   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33393   jresult = (int)result;
33394   return jresult;
33395 }
33396
33397
33398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33399   int jresult ;
33400   int result;
33401
33402   result = (int)Dali::Actor::Property::COLOR_MODE;
33403   jresult = (int)result;
33404   return jresult;
33405 }
33406
33407
33408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33409   int jresult ;
33410   int result;
33411
33412   result = (int)Dali::Actor::Property::DRAW_MODE;
33413   jresult = (int)result;
33414   return jresult;
33415 }
33416
33417
33418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33419   int jresult ;
33420   int result;
33421
33422   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33423   jresult = (int)result;
33424   return jresult;
33425 }
33426
33427
33428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33429   int jresult ;
33430   int result;
33431
33432   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33433   jresult = (int)result;
33434   return jresult;
33435 }
33436
33437
33438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33439   int jresult ;
33440   int result;
33441
33442   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33443   jresult = (int)result;
33444   return jresult;
33445 }
33446
33447
33448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33449   int jresult ;
33450   int result;
33451
33452   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33453   jresult = (int)result;
33454   return jresult;
33455 }
33456
33457
33458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33459   int jresult ;
33460   int result;
33461
33462   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33463   jresult = (int)result;
33464   return jresult;
33465 }
33466
33467
33468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33469   int jresult ;
33470   int result;
33471
33472   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33473   jresult = (int)result;
33474   return jresult;
33475 }
33476
33477
33478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33479   int jresult ;
33480   int result;
33481
33482   result = (int)Dali::Actor::Property::PADDING;
33483   jresult = (int)result;
33484   return jresult;
33485 }
33486
33487
33488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33489   int jresult ;
33490   int result;
33491
33492   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33493   jresult = (int)result;
33494   return jresult;
33495 }
33496
33497
33498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33499   int jresult ;
33500   int result;
33501
33502   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33503   jresult = (int)result;
33504   return jresult;
33505 }
33506
33507
33508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33509   int jresult ;
33510   int result;
33511
33512   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33513   jresult = (int)result;
33514   return jresult;
33515 }
33516
33517
33518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33519   int jresult ;
33520   int result;
33521
33522   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33523   jresult = (int)result;
33524   return jresult;
33525 }
33526
33527
33528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33529   void * jresult ;
33530   Dali::Actor::Property *result = 0 ;
33531
33532   {
33533     try {
33534       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33535     } catch (std::out_of_range& e) {
33536       {
33537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33538       };
33539     } catch (std::exception& e) {
33540       {
33541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33542       };
33543     } catch (Dali::DaliException e) {
33544       {
33545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33546       };
33547     } catch (...) {
33548       {
33549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33550       };
33551     }
33552   }
33553
33554   jresult = (void *)result;
33555   return jresult;
33556 }
33557
33558
33559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33560   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33561
33562   arg1 = (Dali::Actor::Property *)jarg1;
33563   {
33564     try {
33565       delete arg1;
33566     } catch (std::out_of_range& e) {
33567       {
33568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33569       };
33570     } catch (std::exception& e) {
33571       {
33572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33573       };
33574     } catch (Dali::DaliException e) {
33575       {
33576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33577       };
33578     } catch (...) {
33579       {
33580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33581       };
33582     }
33583   }
33584
33585 }
33586
33587
33588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33589   void * jresult ;
33590   Dali::Actor *result = 0 ;
33591
33592   {
33593     try {
33594       result = (Dali::Actor *)new Dali::Actor();
33595     } catch (std::out_of_range& e) {
33596       {
33597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33598       };
33599     } catch (std::exception& e) {
33600       {
33601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33602       };
33603     } catch (Dali::DaliException e) {
33604       {
33605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33606       };
33607     } catch (...) {
33608       {
33609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33610       };
33611     }
33612   }
33613
33614   jresult = (void *)result;
33615   return jresult;
33616 }
33617
33618
33619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33620   void * jresult ;
33621   Dali::Actor result;
33622
33623   {
33624     try {
33625       result = Dali::Actor::New();
33626     } catch (std::out_of_range& e) {
33627       {
33628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33629       };
33630     } catch (std::exception& e) {
33631       {
33632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33633       };
33634     } catch (Dali::DaliException e) {
33635       {
33636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33637       };
33638     } catch (...) {
33639       {
33640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33641       };
33642     }
33643   }
33644
33645   jresult = new Dali::Actor((const Dali::Actor &)result);
33646   return jresult;
33647 }
33648
33649
33650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33651   void * jresult ;
33652   Dali::BaseHandle arg1 ;
33653   Dali::BaseHandle *argp1 ;
33654   Dali::Actor result;
33655
33656   argp1 = (Dali::BaseHandle *)jarg1;
33657   if (!argp1) {
33658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33659     return 0;
33660   }
33661   arg1 = *argp1;
33662   {
33663     try {
33664       result = Dali::Actor::DownCast(arg1);
33665     } catch (std::out_of_range& e) {
33666       {
33667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33668       };
33669     } catch (std::exception& e) {
33670       {
33671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33672       };
33673     } catch (Dali::DaliException e) {
33674       {
33675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33676       };
33677     } catch (...) {
33678       {
33679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33680       };
33681     }
33682   }
33683
33684   jresult = new Dali::Actor((const Dali::Actor &)result);
33685   return jresult;
33686 }
33687
33688
33689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33690   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33691
33692   arg1 = (Dali::Actor *)jarg1;
33693   {
33694     try {
33695       delete arg1;
33696     } catch (std::out_of_range& e) {
33697       {
33698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33699       };
33700     } catch (std::exception& e) {
33701       {
33702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33703       };
33704     } catch (Dali::DaliException e) {
33705       {
33706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33707       };
33708     } catch (...) {
33709       {
33710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33711       };
33712     }
33713   }
33714
33715 }
33716
33717
33718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33719   void * jresult ;
33720   Dali::Actor *arg1 = 0 ;
33721   Dali::Actor *result = 0 ;
33722
33723   arg1 = (Dali::Actor *)jarg1;
33724   if (!arg1) {
33725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33726     return 0;
33727   }
33728   {
33729     try {
33730       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33731     } catch (std::out_of_range& e) {
33732       {
33733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33734       };
33735     } catch (std::exception& e) {
33736       {
33737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33738       };
33739     } catch (Dali::DaliException e) {
33740       {
33741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33742       };
33743     } catch (...) {
33744       {
33745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33746       };
33747     }
33748   }
33749
33750   jresult = (void *)result;
33751   return jresult;
33752 }
33753
33754
33755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33756   void * jresult ;
33757   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33758   Dali::Actor *arg2 = 0 ;
33759   Dali::Actor *result = 0 ;
33760
33761   arg1 = (Dali::Actor *)jarg1;
33762   arg2 = (Dali::Actor *)jarg2;
33763   if (!arg2) {
33764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33765     return 0;
33766   }
33767   {
33768     try {
33769       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33770     } catch (std::out_of_range& e) {
33771       {
33772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33773       };
33774     } catch (std::exception& e) {
33775       {
33776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33777       };
33778     } catch (Dali::DaliException e) {
33779       {
33780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33781       };
33782     } catch (...) {
33783       {
33784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33785       };
33786     }
33787   }
33788
33789   jresult = (void *)result;
33790   return jresult;
33791 }
33792
33793
33794 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33795   char * jresult ;
33796   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33797   std::string *result = 0 ;
33798
33799   arg1 = (Dali::Actor *)jarg1;
33800   {
33801     try {
33802       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
33803     } catch (std::out_of_range& e) {
33804       {
33805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33806       };
33807     } catch (std::exception& e) {
33808       {
33809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33810       };
33811     } catch (Dali::DaliException e) {
33812       {
33813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33814       };
33815     } catch (...) {
33816       {
33817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33818       };
33819     }
33820   }
33821
33822   jresult = SWIG_csharp_string_callback(result->c_str());
33823   return jresult;
33824 }
33825
33826
33827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33828   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33829   std::string *arg2 = 0 ;
33830
33831   arg1 = (Dali::Actor *)jarg1;
33832   if (!jarg2) {
33833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33834     return ;
33835   }
33836   std::string arg2_str(jarg2);
33837   arg2 = &arg2_str;
33838   {
33839     try {
33840       (arg1)->SetName((std::string const &)*arg2);
33841     } catch (std::out_of_range& e) {
33842       {
33843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33844       };
33845     } catch (std::exception& e) {
33846       {
33847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33848       };
33849     } catch (Dali::DaliException e) {
33850       {
33851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33852       };
33853     } catch (...) {
33854       {
33855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33856       };
33857     }
33858   }
33859
33860
33861   //argout typemap for const std::string&
33862
33863 }
33864
33865
33866 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33867   unsigned int jresult ;
33868   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33869   unsigned int result;
33870
33871   arg1 = (Dali::Actor *)jarg1;
33872
33873   if(!arg1) {
33874     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
33875     return -1;
33876   }
33877
33878   {
33879     try {
33880       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
33881     } catch (std::out_of_range& e) {
33882       {
33883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33884       };
33885     } catch (std::exception& e) {
33886       {
33887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33888       };
33889     } catch (Dali::DaliException e) {
33890       {
33891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33892       };
33893     } catch (...) {
33894       {
33895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33896       };
33897     }
33898   }
33899
33900   jresult = result;
33901   return jresult;
33902 }
33903
33904
33905 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33906   unsigned int jresult ;
33907   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33908   bool result;
33909
33910   arg1 = (Dali::Actor *)jarg1;
33911   {
33912     try {
33913       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
33914     } catch (std::out_of_range& e) {
33915       {
33916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33917       };
33918     } catch (std::exception& e) {
33919       {
33920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33921       };
33922     } catch (Dali::DaliException e) {
33923       {
33924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33925       };
33926     } catch (...) {
33927       {
33928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33929       };
33930     }
33931   }
33932
33933   jresult = result;
33934   return jresult;
33935 }
33936
33937
33938 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33939   unsigned int jresult ;
33940   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33941   bool result;
33942
33943   arg1 = (Dali::Actor *)jarg1;
33944   {
33945     try {
33946       result = (bool)((Dali::Actor const *)arg1)->OnStage();
33947     } catch (std::out_of_range& e) {
33948       {
33949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33950       };
33951     } catch (std::exception& e) {
33952       {
33953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33954       };
33955     } catch (Dali::DaliException e) {
33956       {
33957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33958       };
33959     } catch (...) {
33960       {
33961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33962       };
33963     }
33964   }
33965
33966   jresult = result;
33967   return jresult;
33968 }
33969
33970
33971 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33972   unsigned int jresult ;
33973   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33974   bool result;
33975
33976   arg1 = (Dali::Actor *)jarg1;
33977   {
33978     try {
33979       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
33980     } catch (std::out_of_range& e) {
33981       {
33982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33983       };
33984     } catch (std::exception& e) {
33985       {
33986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33987       };
33988     } catch (Dali::DaliException e) {
33989       {
33990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33991       };
33992     } catch (...) {
33993       {
33994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33995       };
33996     }
33997   }
33998
33999   jresult = result;
34000   return jresult;
34001 }
34002
34003
34004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
34005   void * jresult ;
34006   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34007   Dali::Layer result;
34008
34009   arg1 = (Dali::Actor *)jarg1;
34010   {
34011     try {
34012       result = (arg1)->GetLayer();
34013     } catch (std::out_of_range& e) {
34014       {
34015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34016       };
34017     } catch (std::exception& e) {
34018       {
34019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34020       };
34021     } catch (Dali::DaliException e) {
34022       {
34023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34024       };
34025     } catch (...) {
34026       {
34027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34028       };
34029     }
34030   }
34031
34032   jresult = new Dali::Layer((const Dali::Layer &)result);
34033   return jresult;
34034 }
34035
34036
34037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
34038   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34039   Dali::Actor arg2 ;
34040   Dali::Actor *argp2 ;
34041
34042   arg1 = (Dali::Actor *)jarg1;
34043   argp2 = (Dali::Actor *)jarg2;
34044   if (!argp2) {
34045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34046     return ;
34047   }
34048   arg2 = *argp2;
34049   {
34050     try {
34051       (arg1)->Add(arg2);
34052     } catch (std::out_of_range& e) {
34053       {
34054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34055       };
34056     } catch (std::exception& e) {
34057       {
34058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34059       };
34060     } catch (Dali::DaliException e) {
34061       {
34062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34063       };
34064     } catch (...) {
34065       {
34066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34067       };
34068     }
34069   }
34070
34071 }
34072
34073
34074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
34075   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34076   Dali::Actor arg2 ;
34077   Dali::Actor *argp2 ;
34078
34079   arg1 = (Dali::Actor *)jarg1;
34080   argp2 = (Dali::Actor *)jarg2;
34081   if (!argp2) {
34082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34083     return ;
34084   }
34085   arg2 = *argp2;
34086   {
34087     try {
34088       (arg1)->Remove(arg2);
34089     } catch (std::out_of_range& e) {
34090       {
34091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34092       };
34093     } catch (std::exception& e) {
34094       {
34095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34096       };
34097     } catch (Dali::DaliException e) {
34098       {
34099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34100       };
34101     } catch (...) {
34102       {
34103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34104       };
34105     }
34106   }
34107
34108 }
34109
34110
34111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
34112   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34113
34114   arg1 = (Dali::Actor *)jarg1;
34115   {
34116     try {
34117       (arg1)->Unparent();
34118     } catch (std::out_of_range& e) {
34119       {
34120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34121       };
34122     } catch (std::exception& e) {
34123       {
34124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34125       };
34126     } catch (Dali::DaliException e) {
34127       {
34128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34129       };
34130     } catch (...) {
34131       {
34132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34133       };
34134     }
34135   }
34136
34137 }
34138
34139
34140 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
34141   unsigned int jresult ;
34142   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34143   unsigned int result;
34144
34145   arg1 = (Dali::Actor *)jarg1;
34146   {
34147     try {
34148       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
34149     } catch (std::out_of_range& e) {
34150       {
34151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34152       };
34153     } catch (std::exception& e) {
34154       {
34155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34156       };
34157     } catch (Dali::DaliException e) {
34158       {
34159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34160       };
34161     } catch (...) {
34162       {
34163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34164       };
34165     }
34166   }
34167
34168   jresult = result;
34169   return jresult;
34170 }
34171
34172
34173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
34174   void * jresult ;
34175   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34176   unsigned int arg2 ;
34177   Dali::Actor result;
34178
34179   arg1 = (Dali::Actor *)jarg1;
34180   arg2 = (unsigned int)jarg2;
34181   {
34182     try {
34183       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
34184     } catch (std::out_of_range& e) {
34185       {
34186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34187       };
34188     } catch (std::exception& e) {
34189       {
34190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34191       };
34192     } catch (Dali::DaliException e) {
34193       {
34194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34195       };
34196     } catch (...) {
34197       {
34198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34199       };
34200     }
34201   }
34202
34203   jresult = new Dali::Actor((const Dali::Actor &)result);
34204   return jresult;
34205 }
34206
34207
34208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34209   void * jresult ;
34210   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34211   std::string *arg2 = 0 ;
34212   Dali::Actor result;
34213
34214   arg1 = (Dali::Actor *)jarg1;
34215   if (!jarg2) {
34216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34217     return 0;
34218   }
34219   std::string arg2_str(jarg2);
34220   arg2 = &arg2_str;
34221   {
34222     try {
34223       result = (arg1)->FindChildByName((std::string const &)*arg2);
34224     } catch (std::out_of_range& e) {
34225       {
34226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34227       };
34228     } catch (std::exception& e) {
34229       {
34230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34231       };
34232     } catch (Dali::DaliException e) {
34233       {
34234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34235       };
34236     } catch (...) {
34237       {
34238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34239       };
34240     }
34241   }
34242
34243   jresult = new Dali::Actor((const Dali::Actor &)result);
34244
34245   //argout typemap for const std::string&
34246
34247   return jresult;
34248 }
34249
34250
34251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34252   void * jresult ;
34253   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34254   unsigned int arg2 ;
34255   Dali::Actor result;
34256
34257   arg1 = (Dali::Actor *)jarg1;
34258   arg2 = (unsigned int)jarg2;
34259   {
34260     try {
34261       result = (arg1)->FindChildById(arg2);
34262     } catch (std::out_of_range& e) {
34263       {
34264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34265       };
34266     } catch (std::exception& e) {
34267       {
34268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34269       };
34270     } catch (Dali::DaliException e) {
34271       {
34272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34273       };
34274     } catch (...) {
34275       {
34276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34277       };
34278     }
34279   }
34280
34281   jresult = new Dali::Actor((const Dali::Actor &)result);
34282   return jresult;
34283 }
34284
34285
34286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34287   void * jresult ;
34288   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34289   Dali::Actor result;
34290
34291   arg1 = (Dali::Actor *)jarg1;
34292   {
34293     try {
34294       result = ((Dali::Actor const *)arg1)->GetParent();
34295     } catch (std::out_of_range& e) {
34296       {
34297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34298       };
34299     } catch (std::exception& e) {
34300       {
34301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34302       };
34303     } catch (Dali::DaliException e) {
34304       {
34305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34306       };
34307     } catch (...) {
34308       {
34309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34310       };
34311     }
34312   }
34313
34314   jresult = new Dali::Actor((const Dali::Actor &)result);
34315   return jresult;
34316 }
34317
34318
34319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34320   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34321   Dali::Vector3 *arg2 = 0 ;
34322
34323   arg1 = (Dali::Actor *)jarg1;
34324   arg2 = (Dali::Vector3 *)jarg2;
34325   if (!arg2) {
34326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34327     return ;
34328   }
34329   {
34330     try {
34331       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
34332     } catch (std::out_of_range& e) {
34333       {
34334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34335       };
34336     } catch (std::exception& e) {
34337       {
34338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34339       };
34340     } catch (Dali::DaliException e) {
34341       {
34342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34343       };
34344     } catch (...) {
34345       {
34346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34347       };
34348     }
34349   }
34350
34351 }
34352
34353
34354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34355   void * jresult ;
34356   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34357   Dali::Vector3 result;
34358
34359   arg1 = (Dali::Actor *)jarg1;
34360   {
34361     try {
34362       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
34363     } catch (std::out_of_range& e) {
34364       {
34365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34366       };
34367     } catch (std::exception& e) {
34368       {
34369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34370       };
34371     } catch (Dali::DaliException e) {
34372       {
34373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34374       };
34375     } catch (...) {
34376       {
34377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34378       };
34379     }
34380   }
34381
34382   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34383   return jresult;
34384 }
34385
34386
34387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34388   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34389   Dali::Vector3 *arg2 = 0 ;
34390
34391   arg1 = (Dali::Actor *)jarg1;
34392   arg2 = (Dali::Vector3 *)jarg2;
34393   if (!arg2) {
34394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34395     return ;
34396   }
34397   {
34398     try {
34399       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
34400     } catch (std::out_of_range& e) {
34401       {
34402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34403       };
34404     } catch (std::exception& e) {
34405       {
34406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34407       };
34408     } catch (Dali::DaliException e) {
34409       {
34410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34411       };
34412     } catch (...) {
34413       {
34414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34415       };
34416     }
34417   }
34418
34419 }
34420
34421
34422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34423   void * jresult ;
34424   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34425   Dali::Vector3 result;
34426
34427   arg1 = (Dali::Actor *)jarg1;
34428   {
34429     try {
34430       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
34431     } catch (std::out_of_range& e) {
34432       {
34433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34434       };
34435     } catch (std::exception& e) {
34436       {
34437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34438       };
34439     } catch (Dali::DaliException e) {
34440       {
34441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34442       };
34443     } catch (...) {
34444       {
34445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34446       };
34447     }
34448   }
34449
34450   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34451   return jresult;
34452 }
34453
34454
34455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34456   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34457   float arg2 ;
34458   float arg3 ;
34459
34460   arg1 = (Dali::Actor *)jarg1;
34461   arg2 = (float)jarg2;
34462   arg3 = (float)jarg3;
34463   {
34464     try {
34465       (arg1)->SetSize(arg2,arg3);
34466     } catch (std::out_of_range& e) {
34467       {
34468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34469       };
34470     } catch (std::exception& e) {
34471       {
34472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34473       };
34474     } catch (Dali::DaliException e) {
34475       {
34476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34477       };
34478     } catch (...) {
34479       {
34480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34481       };
34482     }
34483   }
34484
34485 }
34486
34487
34488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34489   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34490   float arg2 ;
34491   float arg3 ;
34492   float arg4 ;
34493
34494   arg1 = (Dali::Actor *)jarg1;
34495   arg2 = (float)jarg2;
34496   arg3 = (float)jarg3;
34497   arg4 = (float)jarg4;
34498   {
34499     try {
34500       (arg1)->SetSize(arg2,arg3,arg4);
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_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34524   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34525   Dali::Vector2 *arg2 = 0 ;
34526
34527   arg1 = (Dali::Actor *)jarg1;
34528   arg2 = (Dali::Vector2 *)jarg2;
34529   if (!arg2) {
34530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34531     return ;
34532   }
34533   {
34534     try {
34535       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
34536     } catch (std::out_of_range& e) {
34537       {
34538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34539       };
34540     } catch (std::exception& e) {
34541       {
34542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34543       };
34544     } catch (Dali::DaliException e) {
34545       {
34546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34547       };
34548     } catch (...) {
34549       {
34550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34551       };
34552     }
34553   }
34554
34555 }
34556
34557
34558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34559   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34560   Dali::Vector3 *arg2 = 0 ;
34561
34562   arg1 = (Dali::Actor *)jarg1;
34563   arg2 = (Dali::Vector3 *)jarg2;
34564   if (!arg2) {
34565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34566     return ;
34567   }
34568   {
34569     try {
34570       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
34571     } catch (std::out_of_range& e) {
34572       {
34573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34574       };
34575     } catch (std::exception& e) {
34576       {
34577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34578       };
34579     } catch (Dali::DaliException e) {
34580       {
34581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34582       };
34583     } catch (...) {
34584       {
34585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34586       };
34587     }
34588   }
34589
34590 }
34591
34592
34593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34594   void * jresult ;
34595   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34596   Dali::Vector3 result;
34597
34598   arg1 = (Dali::Actor *)jarg1;
34599   {
34600     try {
34601       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34602     } catch (std::out_of_range& e) {
34603       {
34604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34605       };
34606     } catch (std::exception& e) {
34607       {
34608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34609       };
34610     } catch (Dali::DaliException e) {
34611       {
34612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34613       };
34614     } catch (...) {
34615       {
34616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34617       };
34618     }
34619   }
34620
34621   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34622   return jresult;
34623 }
34624
34625
34626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34627   void * jresult ;
34628   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34629   Dali::Vector3 result;
34630
34631   arg1 = (Dali::Actor *)jarg1;
34632   {
34633     try {
34634       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
34635     } catch (std::out_of_range& e) {
34636       {
34637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34638       };
34639     } catch (std::exception& e) {
34640       {
34641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34642       };
34643     } catch (Dali::DaliException e) {
34644       {
34645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34646       };
34647     } catch (...) {
34648       {
34649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34650       };
34651     }
34652   }
34653
34654   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34655   return jresult;
34656 }
34657
34658
34659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34660   void * jresult ;
34661   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34662   Dali::Vector3 result;
34663
34664   arg1 = (Dali::Actor *)jarg1;
34665   {
34666     try {
34667       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34668     } catch (std::out_of_range& e) {
34669       {
34670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34671       };
34672     } catch (std::exception& e) {
34673       {
34674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34675       };
34676     } catch (Dali::DaliException e) {
34677       {
34678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34679       };
34680     } catch (...) {
34681       {
34682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34683       };
34684     }
34685   }
34686
34687   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34688   return jresult;
34689 }
34690
34691
34692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34693   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34694   float arg2 ;
34695   float arg3 ;
34696
34697   arg1 = (Dali::Actor *)jarg1;
34698   arg2 = (float)jarg2;
34699   arg3 = (float)jarg3;
34700   {
34701     try {
34702       (arg1)->SetPosition(arg2,arg3);
34703     } catch (std::out_of_range& e) {
34704       {
34705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34706       };
34707     } catch (std::exception& e) {
34708       {
34709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34710       };
34711     } catch (Dali::DaliException e) {
34712       {
34713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34714       };
34715     } catch (...) {
34716       {
34717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34718       };
34719     }
34720   }
34721
34722 }
34723
34724
34725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34726   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34727   float arg2 ;
34728   float arg3 ;
34729   float arg4 ;
34730
34731   arg1 = (Dali::Actor *)jarg1;
34732   arg2 = (float)jarg2;
34733   arg3 = (float)jarg3;
34734   arg4 = (float)jarg4;
34735   {
34736     try {
34737       (arg1)->SetPosition(arg2,arg3,arg4);
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_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34761   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34762   Dali::Vector3 *arg2 = 0 ;
34763
34764   arg1 = (Dali::Actor *)jarg1;
34765   arg2 = (Dali::Vector3 *)jarg2;
34766   if (!arg2) {
34767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34768     return ;
34769   }
34770   {
34771     try {
34772       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
34773     } catch (std::out_of_range& e) {
34774       {
34775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34776       };
34777     } catch (std::exception& e) {
34778       {
34779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34780       };
34781     } catch (Dali::DaliException e) {
34782       {
34783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34784       };
34785     } catch (...) {
34786       {
34787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34788       };
34789     }
34790   }
34791
34792 }
34793
34794
34795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34796   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34797   float arg2 ;
34798
34799   arg1 = (Dali::Actor *)jarg1;
34800   arg2 = (float)jarg2;
34801   {
34802     try {
34803       (arg1)->SetX(arg2);
34804     } catch (std::out_of_range& e) {
34805       {
34806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34807       };
34808     } catch (std::exception& e) {
34809       {
34810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34811       };
34812     } catch (Dali::DaliException e) {
34813       {
34814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34815       };
34816     } catch (...) {
34817       {
34818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34819       };
34820     }
34821   }
34822
34823 }
34824
34825
34826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34827   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34828   float arg2 ;
34829
34830   arg1 = (Dali::Actor *)jarg1;
34831   arg2 = (float)jarg2;
34832   {
34833     try {
34834       (arg1)->SetY(arg2);
34835     } catch (std::out_of_range& e) {
34836       {
34837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34838       };
34839     } catch (std::exception& e) {
34840       {
34841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34842       };
34843     } catch (Dali::DaliException e) {
34844       {
34845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34846       };
34847     } catch (...) {
34848       {
34849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34850       };
34851     }
34852   }
34853
34854 }
34855
34856
34857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34858   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34859   float arg2 ;
34860
34861   arg1 = (Dali::Actor *)jarg1;
34862   arg2 = (float)jarg2;
34863   {
34864     try {
34865       (arg1)->SetZ(arg2);
34866     } catch (std::out_of_range& e) {
34867       {
34868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34869       };
34870     } catch (std::exception& e) {
34871       {
34872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34873       };
34874     } catch (Dali::DaliException e) {
34875       {
34876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34877       };
34878     } catch (...) {
34879       {
34880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34881       };
34882     }
34883   }
34884
34885 }
34886
34887
34888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34889   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34890   Dali::Vector3 *arg2 = 0 ;
34891
34892   arg1 = (Dali::Actor *)jarg1;
34893   arg2 = (Dali::Vector3 *)jarg2;
34894   if (!arg2) {
34895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34896     return ;
34897   }
34898   {
34899     try {
34900       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34901     } catch (std::out_of_range& e) {
34902       {
34903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34904       };
34905     } catch (std::exception& e) {
34906       {
34907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34908       };
34909     } catch (Dali::DaliException e) {
34910       {
34911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34912       };
34913     } catch (...) {
34914       {
34915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34916       };
34917     }
34918   }
34919
34920 }
34921
34922
34923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34924   void * jresult ;
34925   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34926   Dali::Vector3 result;
34927
34928   arg1 = (Dali::Actor *)jarg1;
34929   {
34930     try {
34931       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
34932     } catch (std::out_of_range& e) {
34933       {
34934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34935       };
34936     } catch (std::exception& e) {
34937       {
34938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34939       };
34940     } catch (Dali::DaliException e) {
34941       {
34942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34943       };
34944     } catch (...) {
34945       {
34946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34947       };
34948     }
34949   }
34950
34951   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34952   return jresult;
34953 }
34954
34955
34956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34957   void * jresult ;
34958   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34959   Dali::Vector3 result;
34960
34961   arg1 = (Dali::Actor *)jarg1;
34962   {
34963     try {
34964       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
34965     } catch (std::out_of_range& e) {
34966       {
34967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34968       };
34969     } catch (std::exception& e) {
34970       {
34971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34972       };
34973     } catch (Dali::DaliException e) {
34974       {
34975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34976       };
34977     } catch (...) {
34978       {
34979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34980       };
34981     }
34982   }
34983
34984   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34985   return jresult;
34986 }
34987
34988
34989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34990   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34991   bool arg2 ;
34992
34993   arg1 = (Dali::Actor *)jarg1;
34994   arg2 = jarg2 ? true : false;
34995   {
34996     try {
34997       (arg1)->SetInheritPosition(arg2);
34998     } catch (std::out_of_range& e) {
34999       {
35000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35001       };
35002     } catch (std::exception& e) {
35003       {
35004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35005       };
35006     } catch (Dali::DaliException e) {
35007       {
35008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35009       };
35010     } catch (...) {
35011       {
35012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35013       };
35014     }
35015   }
35016
35017 }
35018
35019
35020 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
35021   unsigned int jresult ;
35022   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35023   bool result;
35024
35025   arg1 = (Dali::Actor *)jarg1;
35026   {
35027     try {
35028       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
35029     } catch (std::out_of_range& e) {
35030       {
35031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35032       };
35033     } catch (std::exception& e) {
35034       {
35035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35036       };
35037     } catch (Dali::DaliException e) {
35038       {
35039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35040       };
35041     } catch (...) {
35042       {
35043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35044       };
35045     }
35046   }
35047
35048   jresult = result;
35049   return jresult;
35050 }
35051
35052
35053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35054   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35055   Dali::Degree *arg2 = 0 ;
35056   Dali::Vector3 *arg3 = 0 ;
35057
35058   arg1 = (Dali::Actor *)jarg1;
35059   arg2 = (Dali::Degree *)jarg2;
35060   if (!arg2) {
35061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35062     return ;
35063   }
35064   arg3 = (Dali::Vector3 *)jarg3;
35065   if (!arg3) {
35066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35067     return ;
35068   }
35069   {
35070     try {
35071       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35072     } catch (std::out_of_range& e) {
35073       {
35074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35075       };
35076     } catch (std::exception& e) {
35077       {
35078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35079       };
35080     } catch (Dali::DaliException e) {
35081       {
35082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35083       };
35084     } catch (...) {
35085       {
35086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35087       };
35088     }
35089   }
35090
35091 }
35092
35093
35094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35095   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35096   Dali::Radian *arg2 = 0 ;
35097   Dali::Vector3 *arg3 = 0 ;
35098
35099   arg1 = (Dali::Actor *)jarg1;
35100   arg2 = (Dali::Radian *)jarg2;
35101   if (!arg2) {
35102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35103     return ;
35104   }
35105   arg3 = (Dali::Vector3 *)jarg3;
35106   if (!arg3) {
35107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35108     return ;
35109   }
35110   {
35111     try {
35112       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35113     } catch (std::out_of_range& e) {
35114       {
35115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35116       };
35117     } catch (std::exception& e) {
35118       {
35119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35120       };
35121     } catch (Dali::DaliException e) {
35122       {
35123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35124       };
35125     } catch (...) {
35126       {
35127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35128       };
35129     }
35130   }
35131
35132 }
35133
35134
35135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
35136   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35137   Dali::Quaternion *arg2 = 0 ;
35138
35139   arg1 = (Dali::Actor *)jarg1;
35140   arg2 = (Dali::Quaternion *)jarg2;
35141   if (!arg2) {
35142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35143     return ;
35144   }
35145   {
35146     try {
35147       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
35148     } catch (std::out_of_range& e) {
35149       {
35150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35151       };
35152     } catch (std::exception& e) {
35153       {
35154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35155       };
35156     } catch (Dali::DaliException e) {
35157       {
35158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35159       };
35160     } catch (...) {
35161       {
35162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35163       };
35164     }
35165   }
35166
35167 }
35168
35169
35170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35171   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35172   Dali::Degree *arg2 = 0 ;
35173   Dali::Vector3 *arg3 = 0 ;
35174
35175   arg1 = (Dali::Actor *)jarg1;
35176   arg2 = (Dali::Degree *)jarg2;
35177   if (!arg2) {
35178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35179     return ;
35180   }
35181   arg3 = (Dali::Vector3 *)jarg3;
35182   if (!arg3) {
35183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35184     return ;
35185   }
35186   {
35187     try {
35188       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35189     } catch (std::out_of_range& e) {
35190       {
35191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35192       };
35193     } catch (std::exception& e) {
35194       {
35195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35196       };
35197     } catch (Dali::DaliException e) {
35198       {
35199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35200       };
35201     } catch (...) {
35202       {
35203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35204       };
35205     }
35206   }
35207
35208 }
35209
35210
35211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35212   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35213   Dali::Radian *arg2 = 0 ;
35214   Dali::Vector3 *arg3 = 0 ;
35215
35216   arg1 = (Dali::Actor *)jarg1;
35217   arg2 = (Dali::Radian *)jarg2;
35218   if (!arg2) {
35219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35220     return ;
35221   }
35222   arg3 = (Dali::Vector3 *)jarg3;
35223   if (!arg3) {
35224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35225     return ;
35226   }
35227   {
35228     try {
35229       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35230     } catch (std::out_of_range& e) {
35231       {
35232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35233       };
35234     } catch (std::exception& e) {
35235       {
35236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35237       };
35238     } catch (Dali::DaliException e) {
35239       {
35240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35241       };
35242     } catch (...) {
35243       {
35244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35245       };
35246     }
35247   }
35248
35249 }
35250
35251
35252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35253   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35254   Dali::Quaternion *arg2 = 0 ;
35255
35256   arg1 = (Dali::Actor *)jarg1;
35257   arg2 = (Dali::Quaternion *)jarg2;
35258   if (!arg2) {
35259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35260     return ;
35261   }
35262   {
35263     try {
35264       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35265     } catch (std::out_of_range& e) {
35266       {
35267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35268       };
35269     } catch (std::exception& e) {
35270       {
35271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35272       };
35273     } catch (Dali::DaliException e) {
35274       {
35275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35276       };
35277     } catch (...) {
35278       {
35279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35280       };
35281     }
35282   }
35283
35284 }
35285
35286
35287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35288   void * jresult ;
35289   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35290   Dali::Quaternion result;
35291
35292   arg1 = (Dali::Actor *)jarg1;
35293   {
35294     try {
35295       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
35296     } catch (std::out_of_range& e) {
35297       {
35298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35299       };
35300     } catch (std::exception& e) {
35301       {
35302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35303       };
35304     } catch (Dali::DaliException e) {
35305       {
35306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35307       };
35308     } catch (...) {
35309       {
35310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35311       };
35312     }
35313   }
35314
35315   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35316   return jresult;
35317 }
35318
35319
35320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35321   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35322   bool arg2 ;
35323
35324   arg1 = (Dali::Actor *)jarg1;
35325   arg2 = jarg2 ? true : false;
35326   {
35327     try {
35328       (arg1)->SetInheritOrientation(arg2);
35329     } catch (std::out_of_range& e) {
35330       {
35331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35332       };
35333     } catch (std::exception& e) {
35334       {
35335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35336       };
35337     } catch (Dali::DaliException e) {
35338       {
35339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35340       };
35341     } catch (...) {
35342       {
35343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35344       };
35345     }
35346   }
35347
35348 }
35349
35350
35351 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35352   unsigned int jresult ;
35353   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35354   bool result;
35355
35356   arg1 = (Dali::Actor *)jarg1;
35357   {
35358     try {
35359       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
35360     } catch (std::out_of_range& e) {
35361       {
35362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35363       };
35364     } catch (std::exception& e) {
35365       {
35366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35367       };
35368     } catch (Dali::DaliException e) {
35369       {
35370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35371       };
35372     } catch (...) {
35373       {
35374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35375       };
35376     }
35377   }
35378
35379   jresult = result;
35380   return jresult;
35381 }
35382
35383
35384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35385   void * jresult ;
35386   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35387   Dali::Quaternion result;
35388
35389   arg1 = (Dali::Actor *)jarg1;
35390   {
35391     try {
35392       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
35393     } catch (std::out_of_range& e) {
35394       {
35395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35396       };
35397     } catch (std::exception& e) {
35398       {
35399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35400       };
35401     } catch (Dali::DaliException e) {
35402       {
35403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35404       };
35405     } catch (...) {
35406       {
35407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35408       };
35409     }
35410   }
35411
35412   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35413   return jresult;
35414 }
35415
35416
35417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35418   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35419   float arg2 ;
35420
35421   arg1 = (Dali::Actor *)jarg1;
35422   arg2 = (float)jarg2;
35423   {
35424     try {
35425       (arg1)->SetScale(arg2);
35426     } catch (std::out_of_range& e) {
35427       {
35428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35429       };
35430     } catch (std::exception& e) {
35431       {
35432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35433       };
35434     } catch (Dali::DaliException e) {
35435       {
35436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35437       };
35438     } catch (...) {
35439       {
35440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35441       };
35442     }
35443   }
35444
35445 }
35446
35447
35448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35449   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35450   float arg2 ;
35451   float arg3 ;
35452   float arg4 ;
35453
35454   arg1 = (Dali::Actor *)jarg1;
35455   arg2 = (float)jarg2;
35456   arg3 = (float)jarg3;
35457   arg4 = (float)jarg4;
35458   {
35459     try {
35460       (arg1)->SetScale(arg2,arg3,arg4);
35461     } catch (std::out_of_range& e) {
35462       {
35463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35464       };
35465     } catch (std::exception& e) {
35466       {
35467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35468       };
35469     } catch (Dali::DaliException e) {
35470       {
35471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35472       };
35473     } catch (...) {
35474       {
35475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35476       };
35477     }
35478   }
35479
35480 }
35481
35482
35483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35484   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35485   Dali::Vector3 *arg2 = 0 ;
35486
35487   arg1 = (Dali::Actor *)jarg1;
35488   arg2 = (Dali::Vector3 *)jarg2;
35489   if (!arg2) {
35490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35491     return ;
35492   }
35493   {
35494     try {
35495       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
35496     } catch (std::out_of_range& e) {
35497       {
35498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35499       };
35500     } catch (std::exception& e) {
35501       {
35502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35503       };
35504     } catch (Dali::DaliException e) {
35505       {
35506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35507       };
35508     } catch (...) {
35509       {
35510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35511       };
35512     }
35513   }
35514
35515 }
35516
35517
35518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35519   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35520   Dali::Vector3 *arg2 = 0 ;
35521
35522   arg1 = (Dali::Actor *)jarg1;
35523   arg2 = (Dali::Vector3 *)jarg2;
35524   if (!arg2) {
35525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35526     return ;
35527   }
35528   {
35529     try {
35530       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35531     } catch (std::out_of_range& e) {
35532       {
35533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35534       };
35535     } catch (std::exception& e) {
35536       {
35537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35538       };
35539     } catch (Dali::DaliException e) {
35540       {
35541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35542       };
35543     } catch (...) {
35544       {
35545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35546       };
35547     }
35548   }
35549
35550 }
35551
35552
35553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35554   void * jresult ;
35555   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35556   Dali::Vector3 result;
35557
35558   arg1 = (Dali::Actor *)jarg1;
35559   {
35560     try {
35561       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
35562     } catch (std::out_of_range& e) {
35563       {
35564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35565       };
35566     } catch (std::exception& e) {
35567       {
35568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35569       };
35570     } catch (Dali::DaliException e) {
35571       {
35572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35573       };
35574     } catch (...) {
35575       {
35576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35577       };
35578     }
35579   }
35580
35581   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35582   return jresult;
35583 }
35584
35585
35586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35587   void * jresult ;
35588   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35589   Dali::Vector3 result;
35590
35591   arg1 = (Dali::Actor *)jarg1;
35592   {
35593     try {
35594       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
35595     } catch (std::out_of_range& e) {
35596       {
35597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35598       };
35599     } catch (std::exception& e) {
35600       {
35601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35602       };
35603     } catch (Dali::DaliException e) {
35604       {
35605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35606       };
35607     } catch (...) {
35608       {
35609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35610       };
35611     }
35612   }
35613
35614   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35615   return jresult;
35616 }
35617
35618
35619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35620   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35621   bool arg2 ;
35622
35623   arg1 = (Dali::Actor *)jarg1;
35624   arg2 = jarg2 ? true : false;
35625   {
35626     try {
35627       (arg1)->SetInheritScale(arg2);
35628     } catch (std::out_of_range& e) {
35629       {
35630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35631       };
35632     } catch (std::exception& e) {
35633       {
35634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35635       };
35636     } catch (Dali::DaliException e) {
35637       {
35638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35639       };
35640     } catch (...) {
35641       {
35642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35643       };
35644     }
35645   }
35646
35647 }
35648
35649
35650 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35651   unsigned int jresult ;
35652   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35653   bool result;
35654
35655   arg1 = (Dali::Actor *)jarg1;
35656   {
35657     try {
35658       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
35659     } catch (std::out_of_range& e) {
35660       {
35661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35662       };
35663     } catch (std::exception& e) {
35664       {
35665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35666       };
35667     } catch (Dali::DaliException e) {
35668       {
35669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35670       };
35671     } catch (...) {
35672       {
35673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35674       };
35675     }
35676   }
35677
35678   jresult = result;
35679   return jresult;
35680 }
35681
35682
35683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35684   void * jresult ;
35685   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35686   Dali::Matrix result;
35687
35688   arg1 = (Dali::Actor *)jarg1;
35689   {
35690     try {
35691       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
35692     } catch (std::out_of_range& e) {
35693       {
35694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35695       };
35696     } catch (std::exception& e) {
35697       {
35698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35699       };
35700     } catch (Dali::DaliException e) {
35701       {
35702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35703       };
35704     } catch (...) {
35705       {
35706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35707       };
35708     }
35709   }
35710
35711   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35712   return jresult;
35713 }
35714
35715
35716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35717   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35718   bool arg2 ;
35719
35720   arg1 = (Dali::Actor *)jarg1;
35721   arg2 = jarg2 ? true : false;
35722   {
35723     try {
35724       (arg1)->SetVisible(arg2);
35725     } catch (std::out_of_range& e) {
35726       {
35727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35728       };
35729     } catch (std::exception& e) {
35730       {
35731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35732       };
35733     } catch (Dali::DaliException e) {
35734       {
35735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35736       };
35737     } catch (...) {
35738       {
35739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35740       };
35741     }
35742   }
35743
35744 }
35745
35746
35747 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35748   unsigned int jresult ;
35749   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35750   bool result;
35751
35752   arg1 = (Dali::Actor *)jarg1;
35753   {
35754     try {
35755       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
35756     } catch (std::out_of_range& e) {
35757       {
35758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35759       };
35760     } catch (std::exception& e) {
35761       {
35762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35763       };
35764     } catch (Dali::DaliException e) {
35765       {
35766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35767       };
35768     } catch (...) {
35769       {
35770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35771       };
35772     }
35773   }
35774
35775   jresult = result;
35776   return jresult;
35777 }
35778
35779
35780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35781   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35782   float arg2 ;
35783
35784   arg1 = (Dali::Actor *)jarg1;
35785   arg2 = (float)jarg2;
35786   {
35787     try {
35788       (arg1)->SetOpacity(arg2);
35789     } catch (std::out_of_range& e) {
35790       {
35791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35792       };
35793     } catch (std::exception& e) {
35794       {
35795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35796       };
35797     } catch (Dali::DaliException e) {
35798       {
35799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35800       };
35801     } catch (...) {
35802       {
35803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35804       };
35805     }
35806   }
35807
35808 }
35809
35810
35811 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35812   float jresult ;
35813   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35814   float result;
35815
35816   arg1 = (Dali::Actor *)jarg1;
35817   {
35818     try {
35819       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
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_SetColor(void * jarg1, void * jarg2) {
35845   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35846   Dali::Vector4 *arg2 = 0 ;
35847
35848   arg1 = (Dali::Actor *)jarg1;
35849   arg2 = (Dali::Vector4 *)jarg2;
35850   if (!arg2) {
35851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35852     return ;
35853   }
35854   {
35855     try {
35856       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
35857     } catch (std::out_of_range& e) {
35858       {
35859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35860       };
35861     } catch (std::exception& e) {
35862       {
35863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35864       };
35865     } catch (Dali::DaliException e) {
35866       {
35867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35868       };
35869     } catch (...) {
35870       {
35871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35872       };
35873     }
35874   }
35875
35876 }
35877
35878
35879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35880   void * jresult ;
35881   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35882   Dali::Vector4 result;
35883
35884   arg1 = (Dali::Actor *)jarg1;
35885   {
35886     try {
35887       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
35888     } catch (std::out_of_range& e) {
35889       {
35890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35891       };
35892     } catch (std::exception& e) {
35893       {
35894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35895       };
35896     } catch (Dali::DaliException e) {
35897       {
35898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35899       };
35900     } catch (...) {
35901       {
35902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35903       };
35904     }
35905   }
35906
35907   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35908   return jresult;
35909 }
35910
35911
35912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35913   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35914   Dali::ColorMode arg2 ;
35915
35916   arg1 = (Dali::Actor *)jarg1;
35917   arg2 = (Dali::ColorMode)jarg2;
35918   {
35919     try {
35920       (arg1)->SetColorMode(arg2);
35921     } catch (std::out_of_range& e) {
35922       {
35923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35924       };
35925     } catch (std::exception& e) {
35926       {
35927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35928       };
35929     } catch (Dali::DaliException e) {
35930       {
35931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35932       };
35933     } catch (...) {
35934       {
35935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35936       };
35937     }
35938   }
35939
35940 }
35941
35942
35943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35944   int jresult ;
35945   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35946   Dali::ColorMode result;
35947
35948   arg1 = (Dali::Actor *)jarg1;
35949   {
35950     try {
35951       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
35952     } catch (std::out_of_range& e) {
35953       {
35954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35955       };
35956     } catch (std::exception& e) {
35957       {
35958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35959       };
35960     } catch (Dali::DaliException e) {
35961       {
35962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35963       };
35964     } catch (...) {
35965       {
35966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35967       };
35968     }
35969   }
35970
35971   jresult = (int)result;
35972   return jresult;
35973 }
35974
35975
35976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35977   void * jresult ;
35978   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35979   Dali::Vector4 result;
35980
35981   arg1 = (Dali::Actor *)jarg1;
35982   {
35983     try {
35984       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
35985     } catch (std::out_of_range& e) {
35986       {
35987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35988       };
35989     } catch (std::exception& e) {
35990       {
35991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35992       };
35993     } catch (Dali::DaliException e) {
35994       {
35995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35996       };
35997     } catch (...) {
35998       {
35999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36000       };
36001     }
36002   }
36003
36004   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
36005   return jresult;
36006 }
36007
36008
36009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
36010   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36011   Dali::DrawMode::Type arg2 ;
36012
36013   arg1 = (Dali::Actor *)jarg1;
36014   arg2 = (Dali::DrawMode::Type)jarg2;
36015   {
36016     try {
36017       (arg1)->SetDrawMode(arg2);
36018     } catch (std::out_of_range& e) {
36019       {
36020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36021       };
36022     } catch (std::exception& e) {
36023       {
36024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36025       };
36026     } catch (Dali::DaliException e) {
36027       {
36028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36029       };
36030     } catch (...) {
36031       {
36032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36033       };
36034     }
36035   }
36036
36037 }
36038
36039
36040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
36041   int jresult ;
36042   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36043   Dali::DrawMode::Type result;
36044
36045   arg1 = (Dali::Actor *)jarg1;
36046   {
36047     try {
36048       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
36049     } catch (std::out_of_range& e) {
36050       {
36051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36052       };
36053     } catch (std::exception& e) {
36054       {
36055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36056       };
36057     } catch (Dali::DaliException e) {
36058       {
36059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36060       };
36061     } catch (...) {
36062       {
36063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36064       };
36065     }
36066   }
36067
36068   jresult = (int)result;
36069   return jresult;
36070 }
36071
36072
36073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
36074   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36075   bool arg2 ;
36076
36077   arg1 = (Dali::Actor *)jarg1;
36078   arg2 = jarg2 ? true : false;
36079   {
36080     try {
36081       (arg1)->SetSensitive(arg2);
36082     } catch (std::out_of_range& e) {
36083       {
36084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36085       };
36086     } catch (std::exception& e) {
36087       {
36088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36089       };
36090     } catch (Dali::DaliException e) {
36091       {
36092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36093       };
36094     } catch (...) {
36095       {
36096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36097       };
36098     }
36099   }
36100
36101 }
36102
36103
36104 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
36105   unsigned int jresult ;
36106   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36107   bool result;
36108
36109   arg1 = (Dali::Actor *)jarg1;
36110   {
36111     try {
36112       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
36113     } catch (std::out_of_range& e) {
36114       {
36115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36116       };
36117     } catch (std::exception& e) {
36118       {
36119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36120       };
36121     } catch (Dali::DaliException e) {
36122       {
36123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36124       };
36125     } catch (...) {
36126       {
36127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36128       };
36129     }
36130   }
36131
36132   jresult = result;
36133   return jresult;
36134 }
36135
36136
36137 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
36138   unsigned int jresult ;
36139   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36140   float *arg2 = 0 ;
36141   float *arg3 = 0 ;
36142   float arg4 ;
36143   float arg5 ;
36144   bool result;
36145
36146   arg1 = (Dali::Actor *)jarg1;
36147   arg2 = (float *)jarg2;
36148   arg3 = (float *)jarg3;
36149   arg4 = (float)jarg4;
36150   arg5 = (float)jarg5;
36151   {
36152     try {
36153       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
36154     } catch (std::out_of_range& e) {
36155       {
36156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36157       };
36158     } catch (std::exception& e) {
36159       {
36160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36161       };
36162     } catch (Dali::DaliException e) {
36163       {
36164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36165       };
36166     } catch (...) {
36167       {
36168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36169       };
36170     }
36171   }
36172
36173   jresult = result;
36174   return jresult;
36175 }
36176
36177
36178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
36179   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36180   bool arg2 ;
36181
36182   arg1 = (Dali::Actor *)jarg1;
36183   arg2 = jarg2 ? true : false;
36184   {
36185     try {
36186       (arg1)->SetLeaveRequired(arg2);
36187     } catch (std::out_of_range& e) {
36188       {
36189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36190       };
36191     } catch (std::exception& e) {
36192       {
36193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36194       };
36195     } catch (Dali::DaliException e) {
36196       {
36197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36198       };
36199     } catch (...) {
36200       {
36201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36202       };
36203     }
36204   }
36205
36206 }
36207
36208
36209 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36210   unsigned int jresult ;
36211   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36212   bool result;
36213
36214   arg1 = (Dali::Actor *)jarg1;
36215   {
36216     try {
36217       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
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 void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36243   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36244   bool arg2 ;
36245
36246   arg1 = (Dali::Actor *)jarg1;
36247   arg2 = jarg2 ? true : false;
36248   {
36249     try {
36250       (arg1)->SetKeyboardFocusable(arg2);
36251     } catch (std::out_of_range& e) {
36252       {
36253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36254       };
36255     } catch (std::exception& e) {
36256       {
36257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36258       };
36259     } catch (Dali::DaliException e) {
36260       {
36261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36262       };
36263     } catch (...) {
36264       {
36265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36266       };
36267     }
36268   }
36269
36270 }
36271
36272
36273 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36274   unsigned int jresult ;
36275   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36276   bool result;
36277
36278   arg1 = (Dali::Actor *)jarg1;
36279   {
36280     try {
36281       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
36282     } catch (std::out_of_range& e) {
36283       {
36284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36285       };
36286     } catch (std::exception& e) {
36287       {
36288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36289       };
36290     } catch (Dali::DaliException e) {
36291       {
36292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36293       };
36294     } catch (...) {
36295       {
36296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36297       };
36298     }
36299   }
36300
36301   jresult = result;
36302   return jresult;
36303 }
36304
36305
36306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36307   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36308   Dali::ResizePolicy::Type arg2 ;
36309   Dali::Dimension::Type arg3 ;
36310
36311   arg1 = (Dali::Actor *)jarg1;
36312   arg2 = (Dali::ResizePolicy::Type)jarg2;
36313   arg3 = (Dali::Dimension::Type)jarg3;
36314   {
36315     try {
36316       (arg1)->SetResizePolicy(arg2,arg3);
36317     } catch (std::out_of_range& e) {
36318       {
36319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36320       };
36321     } catch (std::exception& e) {
36322       {
36323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36324       };
36325     } catch (Dali::DaliException e) {
36326       {
36327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36328       };
36329     } catch (...) {
36330       {
36331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36332       };
36333     }
36334   }
36335
36336 }
36337
36338
36339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36340   int jresult ;
36341   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36342   Dali::Dimension::Type arg2 ;
36343   Dali::ResizePolicy::Type result;
36344
36345   arg1 = (Dali::Actor *)jarg1;
36346   arg2 = (Dali::Dimension::Type)jarg2;
36347   {
36348     try {
36349       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36350     } catch (std::out_of_range& e) {
36351       {
36352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36353       };
36354     } catch (std::exception& e) {
36355       {
36356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36357       };
36358     } catch (Dali::DaliException e) {
36359       {
36360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36361       };
36362     } catch (...) {
36363       {
36364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36365       };
36366     }
36367   }
36368
36369   jresult = (int)result;
36370   return jresult;
36371 }
36372
36373
36374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36375   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36376   Dali::SizeScalePolicy::Type arg2 ;
36377
36378   arg1 = (Dali::Actor *)jarg1;
36379   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36380   {
36381     try {
36382       (arg1)->SetSizeScalePolicy(arg2);
36383     } catch (std::out_of_range& e) {
36384       {
36385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36386       };
36387     } catch (std::exception& e) {
36388       {
36389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36390       };
36391     } catch (Dali::DaliException e) {
36392       {
36393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36394       };
36395     } catch (...) {
36396       {
36397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36398       };
36399     }
36400   }
36401
36402 }
36403
36404
36405 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36406   int jresult ;
36407   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36408   Dali::SizeScalePolicy::Type result;
36409
36410   arg1 = (Dali::Actor *)jarg1;
36411   {
36412     try {
36413       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
36414     } catch (std::out_of_range& e) {
36415       {
36416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36417       };
36418     } catch (std::exception& e) {
36419       {
36420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36421       };
36422     } catch (Dali::DaliException e) {
36423       {
36424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36425       };
36426     } catch (...) {
36427       {
36428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36429       };
36430     }
36431   }
36432
36433   jresult = (int)result;
36434   return jresult;
36435 }
36436
36437
36438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36439   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36440   Dali::Vector3 *arg2 = 0 ;
36441
36442   arg1 = (Dali::Actor *)jarg1;
36443   arg2 = (Dali::Vector3 *)jarg2;
36444   if (!arg2) {
36445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36446     return ;
36447   }
36448   {
36449     try {
36450       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
36451     } catch (std::out_of_range& e) {
36452       {
36453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36454       };
36455     } catch (std::exception& e) {
36456       {
36457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36458       };
36459     } catch (Dali::DaliException e) {
36460       {
36461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36462       };
36463     } catch (...) {
36464       {
36465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36466       };
36467     }
36468   }
36469
36470 }
36471
36472
36473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36474   void * jresult ;
36475   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36476   Dali::Vector3 result;
36477
36478   arg1 = (Dali::Actor *)jarg1;
36479   {
36480     try {
36481       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
36482     } catch (std::out_of_range& e) {
36483       {
36484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36485       };
36486     } catch (std::exception& e) {
36487       {
36488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36489       };
36490     } catch (Dali::DaliException e) {
36491       {
36492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36493       };
36494     } catch (...) {
36495       {
36496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36497       };
36498     }
36499   }
36500
36501   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36502   return jresult;
36503 }
36504
36505
36506 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36507   float jresult ;
36508   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36509   float arg2 ;
36510   float result;
36511
36512   arg1 = (Dali::Actor *)jarg1;
36513   arg2 = (float)jarg2;
36514   {
36515     try {
36516       result = (float)(arg1)->GetHeightForWidth(arg2);
36517     } catch (std::out_of_range& e) {
36518       {
36519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36520       };
36521     } catch (std::exception& e) {
36522       {
36523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36524       };
36525     } catch (Dali::DaliException e) {
36526       {
36527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36528       };
36529     } catch (...) {
36530       {
36531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36532       };
36533     }
36534   }
36535
36536   jresult = result;
36537   return jresult;
36538 }
36539
36540
36541 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36542   float jresult ;
36543   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36544   float arg2 ;
36545   float result;
36546
36547   arg1 = (Dali::Actor *)jarg1;
36548   arg2 = (float)jarg2;
36549   {
36550     try {
36551       result = (float)(arg1)->GetWidthForHeight(arg2);
36552     } catch (std::out_of_range& e) {
36553       {
36554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36555       };
36556     } catch (std::exception& e) {
36557       {
36558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36559       };
36560     } catch (Dali::DaliException e) {
36561       {
36562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36563       };
36564     } catch (...) {
36565       {
36566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36567       };
36568     }
36569   }
36570
36571   jresult = result;
36572   return jresult;
36573 }
36574
36575
36576 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36577   float jresult ;
36578   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36579   Dali::Dimension::Type arg2 ;
36580   float result;
36581
36582   arg1 = (Dali::Actor *)jarg1;
36583   arg2 = (Dali::Dimension::Type)jarg2;
36584   {
36585     try {
36586       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36587     } catch (std::out_of_range& e) {
36588       {
36589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36590       };
36591     } catch (std::exception& e) {
36592       {
36593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36594       };
36595     } catch (Dali::DaliException e) {
36596       {
36597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36598       };
36599     } catch (...) {
36600       {
36601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36602       };
36603     }
36604   }
36605
36606   jresult = result;
36607   return jresult;
36608 }
36609
36610
36611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36612   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36613   Dali::Padding *arg2 = 0 ;
36614
36615   arg1 = (Dali::Actor *)jarg1;
36616   arg2 = (Dali::Padding *)jarg2;
36617   if (!arg2) {
36618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36619     return ;
36620   }
36621   {
36622     try {
36623       (arg1)->SetPadding((Dali::Padding const &)*arg2);
36624     } catch (std::out_of_range& e) {
36625       {
36626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36627       };
36628     } catch (std::exception& e) {
36629       {
36630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36631       };
36632     } catch (Dali::DaliException e) {
36633       {
36634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36635       };
36636     } catch (...) {
36637       {
36638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36639       };
36640     }
36641   }
36642
36643 }
36644
36645
36646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36647   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36648   Dali::Padding *arg2 = 0 ;
36649
36650   arg1 = (Dali::Actor *)jarg1;
36651   arg2 = (Dali::Padding *)jarg2;
36652   if (!arg2) {
36653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36654     return ;
36655   }
36656   {
36657     try {
36658       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
36659     } catch (std::out_of_range& e) {
36660       {
36661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36662       };
36663     } catch (std::exception& e) {
36664       {
36665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36666       };
36667     } catch (Dali::DaliException e) {
36668       {
36669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36670       };
36671     } catch (...) {
36672       {
36673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36674       };
36675     }
36676   }
36677
36678 }
36679
36680
36681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36682   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36683   Dali::Vector2 *arg2 = 0 ;
36684
36685   arg1 = (Dali::Actor *)jarg1;
36686   arg2 = (Dali::Vector2 *)jarg2;
36687   if (!arg2) {
36688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36689     return ;
36690   }
36691   {
36692     try {
36693       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
36694     } catch (std::out_of_range& e) {
36695       {
36696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36697       };
36698     } catch (std::exception& e) {
36699       {
36700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36701       };
36702     } catch (Dali::DaliException e) {
36703       {
36704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36705       };
36706     } catch (...) {
36707       {
36708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36709       };
36710     }
36711   }
36712
36713 }
36714
36715
36716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36717   void * jresult ;
36718   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36719   Dali::Vector2 result;
36720
36721   arg1 = (Dali::Actor *)jarg1;
36722   {
36723     try {
36724       result = (arg1)->GetMinimumSize();
36725     } catch (std::out_of_range& e) {
36726       {
36727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36728       };
36729     } catch (std::exception& e) {
36730       {
36731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36732       };
36733     } catch (Dali::DaliException e) {
36734       {
36735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36736       };
36737     } catch (...) {
36738       {
36739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36740       };
36741     }
36742   }
36743
36744   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36745   return jresult;
36746 }
36747
36748
36749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36750   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36751   Dali::Vector2 *arg2 = 0 ;
36752
36753   arg1 = (Dali::Actor *)jarg1;
36754   arg2 = (Dali::Vector2 *)jarg2;
36755   if (!arg2) {
36756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36757     return ;
36758   }
36759   {
36760     try {
36761       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
36762     } catch (std::out_of_range& e) {
36763       {
36764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36765       };
36766     } catch (std::exception& e) {
36767       {
36768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36769       };
36770     } catch (Dali::DaliException e) {
36771       {
36772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36773       };
36774     } catch (...) {
36775       {
36776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36777       };
36778     }
36779   }
36780
36781 }
36782
36783
36784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36785   void * jresult ;
36786   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36787   Dali::Vector2 result;
36788
36789   arg1 = (Dali::Actor *)jarg1;
36790   {
36791     try {
36792       result = (arg1)->GetMaximumSize();
36793     } catch (std::out_of_range& e) {
36794       {
36795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36796       };
36797     } catch (std::exception& e) {
36798       {
36799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36800       };
36801     } catch (Dali::DaliException e) {
36802       {
36803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36804       };
36805     } catch (...) {
36806       {
36807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36808       };
36809     }
36810   }
36811
36812   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36813   return jresult;
36814 }
36815
36816
36817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36818   int jresult ;
36819   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36820   int result;
36821
36822   arg1 = (Dali::Actor *)jarg1;
36823   {
36824     try {
36825       result = (int)(arg1)->GetHierarchyDepth();
36826       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36827     } catch (std::out_of_range& e) {
36828       {
36829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36830       };
36831     } catch (std::exception& e) {
36832       {
36833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36834       };
36835     } catch (Dali::DaliException e) {
36836       {
36837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36838       };
36839     } catch (...) {
36840       {
36841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36842       };
36843     }
36844   }
36845
36846   jresult = result;
36847   return jresult;
36848 }
36849
36850
36851 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36852   unsigned int jresult ;
36853   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36854   Dali::Renderer *arg2 = 0 ;
36855   unsigned int result;
36856
36857   arg1 = (Dali::Actor *)jarg1;
36858   arg2 = (Dali::Renderer *)jarg2;
36859   if (!arg2) {
36860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36861     return 0;
36862   }
36863   {
36864     try {
36865       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36866     } catch (std::out_of_range& e) {
36867       {
36868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36869       };
36870     } catch (std::exception& e) {
36871       {
36872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36873       };
36874     } catch (Dali::DaliException e) {
36875       {
36876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36877       };
36878     } catch (...) {
36879       {
36880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36881       };
36882     }
36883   }
36884
36885   jresult = result;
36886   return jresult;
36887 }
36888
36889
36890 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36891   unsigned int jresult ;
36892   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36893   unsigned int result;
36894
36895   arg1 = (Dali::Actor *)jarg1;
36896   {
36897     try {
36898       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36899     } catch (std::out_of_range& e) {
36900       {
36901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36902       };
36903     } catch (std::exception& e) {
36904       {
36905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36906       };
36907     } catch (Dali::DaliException e) {
36908       {
36909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36910       };
36911     } catch (...) {
36912       {
36913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36914       };
36915     }
36916   }
36917
36918   jresult = result;
36919   return jresult;
36920 }
36921
36922
36923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36924   void * jresult ;
36925   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36926   unsigned int arg2 ;
36927   Dali::Renderer result;
36928
36929   arg1 = (Dali::Actor *)jarg1;
36930   arg2 = (unsigned int)jarg2;
36931   {
36932     try {
36933       result = (arg1)->GetRendererAt(arg2);
36934     } catch (std::out_of_range& e) {
36935       {
36936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36937       };
36938     } catch (std::exception& e) {
36939       {
36940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36941       };
36942     } catch (Dali::DaliException e) {
36943       {
36944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36945       };
36946     } catch (...) {
36947       {
36948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36949       };
36950     }
36951   }
36952
36953   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36954   return jresult;
36955 }
36956
36957
36958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36959   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36960   Dali::Renderer *arg2 = 0 ;
36961
36962   arg1 = (Dali::Actor *)jarg1;
36963   arg2 = (Dali::Renderer *)jarg2;
36964   if (!arg2) {
36965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36966     return ;
36967   }
36968   {
36969     try {
36970       (arg1)->RemoveRenderer(*arg2);
36971     } catch (std::out_of_range& e) {
36972       {
36973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36974       };
36975     } catch (std::exception& e) {
36976       {
36977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36978       };
36979     } catch (Dali::DaliException e) {
36980       {
36981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36982       };
36983     } catch (...) {
36984       {
36985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36986       };
36987     }
36988   }
36989
36990 }
36991
36992
36993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36994   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36995   unsigned int arg2 ;
36996
36997   arg1 = (Dali::Actor *)jarg1;
36998   arg2 = (unsigned int)jarg2;
36999   {
37000     try {
37001       (arg1)->RemoveRenderer(arg2);
37002     } catch (std::out_of_range& e) {
37003       {
37004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37005       };
37006     } catch (std::exception& e) {
37007       {
37008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37009       };
37010     } catch (Dali::DaliException e) {
37011       {
37012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37013       };
37014     } catch (...) {
37015       {
37016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37017       };
37018     }
37019   }
37020
37021 }
37022
37023
37024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
37025   void * jresult ;
37026   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37027   Dali::Actor::TouchSignalType *result = 0 ;
37028
37029   arg1 = (Dali::Actor *)jarg1;
37030   {
37031     try {
37032       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
37033     } catch (std::out_of_range& e) {
37034       {
37035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37036       };
37037     } catch (std::exception& e) {
37038       {
37039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37040       };
37041     } catch (Dali::DaliException e) {
37042       {
37043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37044       };
37045     } catch (...) {
37046       {
37047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37048       };
37049     }
37050   }
37051
37052   jresult = (void *)result;
37053   return jresult;
37054 }
37055
37056
37057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
37058   void * jresult ;
37059   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37060   Dali::Actor::TouchDataSignalType *result = 0 ;
37061
37062   arg1 = (Dali::Actor *)jarg1;
37063   {
37064     try {
37065       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
37066     } catch (std::out_of_range& e) {
37067       {
37068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37069       };
37070     } catch (std::exception& e) {
37071       {
37072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37073       };
37074     } catch (Dali::DaliException e) {
37075       {
37076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37077       };
37078     } catch (...) {
37079       {
37080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37081       };
37082     }
37083   }
37084
37085   jresult = (void *)result;
37086   return jresult;
37087 }
37088
37089
37090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
37091   void * jresult ;
37092   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37093   Dali::Actor::HoverSignalType *result = 0 ;
37094
37095   arg1 = (Dali::Actor *)jarg1;
37096   {
37097     try {
37098       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
37099     } catch (std::out_of_range& e) {
37100       {
37101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37102       };
37103     } catch (std::exception& e) {
37104       {
37105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37106       };
37107     } catch (Dali::DaliException e) {
37108       {
37109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37110       };
37111     } catch (...) {
37112       {
37113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37114       };
37115     }
37116   }
37117
37118   jresult = (void *)result;
37119   return jresult;
37120 }
37121
37122
37123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
37124   void * jresult ;
37125   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37126   Dali::Actor::WheelEventSignalType *result = 0 ;
37127
37128   arg1 = (Dali::Actor *)jarg1;
37129   {
37130     try {
37131       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
37132     } catch (std::out_of_range& e) {
37133       {
37134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37135       };
37136     } catch (std::exception& e) {
37137       {
37138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37139       };
37140     } catch (Dali::DaliException e) {
37141       {
37142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37143       };
37144     } catch (...) {
37145       {
37146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37147       };
37148     }
37149   }
37150
37151   jresult = (void *)result;
37152   return jresult;
37153 }
37154
37155
37156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
37157   void * jresult ;
37158   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37159   Dali::Actor::OnStageSignalType *result = 0 ;
37160
37161   arg1 = (Dali::Actor *)jarg1;
37162   {
37163     try {
37164       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
37165     } catch (std::out_of_range& e) {
37166       {
37167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37168       };
37169     } catch (std::exception& e) {
37170       {
37171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37172       };
37173     } catch (Dali::DaliException e) {
37174       {
37175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37176       };
37177     } catch (...) {
37178       {
37179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37180       };
37181     }
37182   }
37183
37184   jresult = (void *)result;
37185   return jresult;
37186 }
37187
37188
37189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
37190   void * jresult ;
37191   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37192   Dali::Actor::OffStageSignalType *result = 0 ;
37193
37194   arg1 = (Dali::Actor *)jarg1;
37195   {
37196     try {
37197       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
37198     } catch (std::out_of_range& e) {
37199       {
37200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37201       };
37202     } catch (std::exception& e) {
37203       {
37204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37205       };
37206     } catch (Dali::DaliException e) {
37207       {
37208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37209       };
37210     } catch (...) {
37211       {
37212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37213       };
37214     }
37215   }
37216
37217   jresult = (void *)result;
37218   return jresult;
37219 }
37220
37221
37222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
37223   void * jresult ;
37224   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37225   Dali::Actor::OnRelayoutSignalType *result = 0 ;
37226
37227   arg1 = (Dali::Actor *)jarg1;
37228   {
37229     try {
37230       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
37231     } catch (std::out_of_range& e) {
37232       {
37233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37234       };
37235     } catch (std::exception& e) {
37236       {
37237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37238       };
37239     } catch (Dali::DaliException e) {
37240       {
37241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37242       };
37243     } catch (...) {
37244       {
37245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37246       };
37247     }
37248   }
37249
37250   jresult = (void *)result;
37251   return jresult;
37252 }
37253
37254
37255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37256   Dali::Actor *arg1 = 0 ;
37257
37258   arg1 = (Dali::Actor *)jarg1;
37259   if (!arg1) {
37260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37261     return ;
37262   }
37263   {
37264     try {
37265       Dali::UnparentAndReset(*arg1);
37266     } catch (std::out_of_range& e) {
37267       {
37268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37269       };
37270     } catch (std::exception& e) {
37271       {
37272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37273       };
37274     } catch (Dali::DaliException e) {
37275       {
37276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37277       };
37278     } catch (...) {
37279       {
37280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37281       };
37282     }
37283   }
37284
37285 }
37286
37287
37288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37289   int jresult ;
37290   int result;
37291
37292   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37293   jresult = (int)result;
37294   return jresult;
37295 }
37296
37297
37298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37299   int jresult ;
37300   int result;
37301
37302   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37303   jresult = (int)result;
37304   return jresult;
37305 }
37306
37307
37308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37309   int jresult ;
37310   int result;
37311
37312   result = (int)Dali::Layer::Property::BEHAVIOR;
37313   jresult = (int)result;
37314   return jresult;
37315 }
37316
37317
37318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37319   void * jresult ;
37320   Dali::Layer::Property *result = 0 ;
37321
37322   {
37323     try {
37324       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37325     } catch (std::out_of_range& e) {
37326       {
37327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37328       };
37329     } catch (std::exception& e) {
37330       {
37331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37332       };
37333     } catch (Dali::DaliException e) {
37334       {
37335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37336       };
37337     } catch (...) {
37338       {
37339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37340       };
37341     }
37342   }
37343
37344   jresult = (void *)result;
37345   return jresult;
37346 }
37347
37348
37349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37350   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37351
37352   arg1 = (Dali::Layer::Property *)jarg1;
37353   {
37354     try {
37355       delete arg1;
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_new_Layer__SWIG_0() {
37379   void * jresult ;
37380   Dali::Layer *result = 0 ;
37381
37382   {
37383     try {
37384       result = (Dali::Layer *)new Dali::Layer();
37385     } catch (std::out_of_range& e) {
37386       {
37387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37388       };
37389     } catch (std::exception& e) {
37390       {
37391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37392       };
37393     } catch (Dali::DaliException e) {
37394       {
37395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37396       };
37397     } catch (...) {
37398       {
37399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37400       };
37401     }
37402   }
37403
37404   jresult = (void *)result;
37405   return jresult;
37406 }
37407
37408
37409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37410   void * jresult ;
37411   Dali::Layer result;
37412
37413   {
37414     try {
37415       result = Dali::Layer::New();
37416     } catch (std::out_of_range& e) {
37417       {
37418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37419       };
37420     } catch (std::exception& e) {
37421       {
37422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37423       };
37424     } catch (Dali::DaliException e) {
37425       {
37426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37427       };
37428     } catch (...) {
37429       {
37430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37431       };
37432     }
37433   }
37434
37435   jresult = new Dali::Layer((const Dali::Layer &)result);
37436   return jresult;
37437 }
37438
37439
37440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37441   void * jresult ;
37442   Dali::BaseHandle arg1 ;
37443   Dali::BaseHandle *argp1 ;
37444   Dali::Layer result;
37445
37446   argp1 = (Dali::BaseHandle *)jarg1;
37447   if (!argp1) {
37448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37449     return 0;
37450   }
37451   arg1 = *argp1;
37452   {
37453     try {
37454       result = Dali::Layer::DownCast(arg1);
37455     } catch (std::out_of_range& e) {
37456       {
37457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37458       };
37459     } catch (std::exception& e) {
37460       {
37461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37462       };
37463     } catch (Dali::DaliException e) {
37464       {
37465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37466       };
37467     } catch (...) {
37468       {
37469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37470       };
37471     }
37472   }
37473
37474   jresult = new Dali::Layer((const Dali::Layer &)result);
37475   return jresult;
37476 }
37477
37478
37479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37480   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37481
37482   arg1 = (Dali::Layer *)jarg1;
37483   {
37484     try {
37485       delete arg1;
37486     } catch (std::out_of_range& e) {
37487       {
37488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37489       };
37490     } catch (std::exception& e) {
37491       {
37492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37493       };
37494     } catch (Dali::DaliException e) {
37495       {
37496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37497       };
37498     } catch (...) {
37499       {
37500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37501       };
37502     }
37503   }
37504
37505 }
37506
37507
37508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37509   void * jresult ;
37510   Dali::Layer *arg1 = 0 ;
37511   Dali::Layer *result = 0 ;
37512
37513   arg1 = (Dali::Layer *)jarg1;
37514   if (!arg1) {
37515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37516     return 0;
37517   }
37518   {
37519     try {
37520       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37521     } catch (std::out_of_range& e) {
37522       {
37523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37524       };
37525     } catch (std::exception& e) {
37526       {
37527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37528       };
37529     } catch (Dali::DaliException e) {
37530       {
37531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37532       };
37533     } catch (...) {
37534       {
37535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37536       };
37537     }
37538   }
37539
37540   jresult = (void *)result;
37541   return jresult;
37542 }
37543
37544
37545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37546   void * jresult ;
37547   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37548   Dali::Layer *arg2 = 0 ;
37549   Dali::Layer *result = 0 ;
37550
37551   arg1 = (Dali::Layer *)jarg1;
37552   arg2 = (Dali::Layer *)jarg2;
37553   if (!arg2) {
37554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37555     return 0;
37556   }
37557   {
37558     try {
37559       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37560     } catch (std::out_of_range& e) {
37561       {
37562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37563       };
37564     } catch (std::exception& e) {
37565       {
37566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37567       };
37568     } catch (Dali::DaliException e) {
37569       {
37570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37571       };
37572     } catch (...) {
37573       {
37574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37575       };
37576     }
37577   }
37578
37579   jresult = (void *)result;
37580   return jresult;
37581 }
37582
37583
37584 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37585   unsigned int jresult ;
37586   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37587   unsigned int result;
37588
37589   arg1 = (Dali::Layer *)jarg1;
37590   {
37591     try {
37592       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
37593     } catch (std::out_of_range& e) {
37594       {
37595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37596       };
37597     } catch (std::exception& e) {
37598       {
37599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37600       };
37601     } catch (Dali::DaliException e) {
37602       {
37603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37604       };
37605     } catch (...) {
37606       {
37607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37608       };
37609     }
37610   }
37611
37612   jresult = result;
37613   return jresult;
37614 }
37615
37616
37617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37618   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37619
37620   arg1 = (Dali::Layer *)jarg1;
37621   {
37622     try {
37623       (arg1)->Raise();
37624     } catch (std::out_of_range& e) {
37625       {
37626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37627       };
37628     } catch (std::exception& e) {
37629       {
37630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37631       };
37632     } catch (Dali::DaliException e) {
37633       {
37634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37635       };
37636     } catch (...) {
37637       {
37638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37639       };
37640     }
37641   }
37642
37643 }
37644
37645
37646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37647   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37648
37649   arg1 = (Dali::Layer *)jarg1;
37650   {
37651     try {
37652       (arg1)->Lower();
37653     } catch (std::out_of_range& e) {
37654       {
37655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37656       };
37657     } catch (std::exception& e) {
37658       {
37659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37660       };
37661     } catch (Dali::DaliException e) {
37662       {
37663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37664       };
37665     } catch (...) {
37666       {
37667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37668       };
37669     }
37670   }
37671
37672 }
37673
37674
37675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37676   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37677   Dali::Layer arg2 ;
37678   Dali::Layer *argp2 ;
37679
37680   arg1 = (Dali::Layer *)jarg1;
37681   argp2 = (Dali::Layer *)jarg2;
37682   if (!argp2) {
37683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37684     return ;
37685   }
37686   arg2 = *argp2;
37687   {
37688     try {
37689       (arg1)->RaiseAbove(arg2);
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_LowerBelow(void * jarg1, void * jarg2) {
37713   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37714   Dali::Layer arg2 ;
37715   Dali::Layer *argp2 ;
37716
37717   arg1 = (Dali::Layer *)jarg1;
37718   argp2 = (Dali::Layer *)jarg2;
37719   if (!argp2) {
37720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37721     return ;
37722   }
37723   arg2 = *argp2;
37724   {
37725     try {
37726       (arg1)->LowerBelow(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_RaiseToTop(void * jarg1) {
37750   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37751
37752   arg1 = (Dali::Layer *)jarg1;
37753   {
37754     try {
37755       (arg1)->RaiseToTop();
37756     } catch (std::out_of_range& e) {
37757       {
37758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37759       };
37760     } catch (std::exception& e) {
37761       {
37762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37763       };
37764     } catch (Dali::DaliException e) {
37765       {
37766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37767       };
37768     } catch (...) {
37769       {
37770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37771       };
37772     }
37773   }
37774
37775 }
37776
37777
37778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37779   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37780
37781   arg1 = (Dali::Layer *)jarg1;
37782   {
37783     try {
37784       (arg1)->LowerToBottom();
37785     } catch (std::out_of_range& e) {
37786       {
37787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37788       };
37789     } catch (std::exception& e) {
37790       {
37791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37792       };
37793     } catch (Dali::DaliException e) {
37794       {
37795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37796       };
37797     } catch (...) {
37798       {
37799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37800       };
37801     }
37802   }
37803
37804 }
37805
37806
37807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37808   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37809   Dali::Layer arg2 ;
37810   Dali::Layer *argp2 ;
37811
37812   arg1 = (Dali::Layer *)jarg1;
37813   argp2 = (Dali::Layer *)jarg2;
37814   if (!argp2) {
37815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37816     return ;
37817   }
37818   arg2 = *argp2;
37819   {
37820     try {
37821       (arg1)->MoveAbove(arg2);
37822     } catch (std::out_of_range& e) {
37823       {
37824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37825       };
37826     } catch (std::exception& e) {
37827       {
37828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37829       };
37830     } catch (Dali::DaliException e) {
37831       {
37832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37833       };
37834     } catch (...) {
37835       {
37836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37837       };
37838     }
37839   }
37840
37841 }
37842
37843
37844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37845   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37846   Dali::Layer arg2 ;
37847   Dali::Layer *argp2 ;
37848
37849   arg1 = (Dali::Layer *)jarg1;
37850   argp2 = (Dali::Layer *)jarg2;
37851   if (!argp2) {
37852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37853     return ;
37854   }
37855   arg2 = *argp2;
37856   {
37857     try {
37858       (arg1)->MoveBelow(arg2);
37859     } catch (std::out_of_range& e) {
37860       {
37861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37862       };
37863     } catch (std::exception& e) {
37864       {
37865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37866       };
37867     } catch (Dali::DaliException e) {
37868       {
37869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37870       };
37871     } catch (...) {
37872       {
37873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37874       };
37875     }
37876   }
37877
37878 }
37879
37880
37881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37882   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37883   Dali::Layer::Behavior arg2 ;
37884
37885   arg1 = (Dali::Layer *)jarg1;
37886   arg2 = (Dali::Layer::Behavior)jarg2;
37887   {
37888     try {
37889       (arg1)->SetBehavior(arg2);
37890     } catch (std::out_of_range& e) {
37891       {
37892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37893       };
37894     } catch (std::exception& e) {
37895       {
37896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37897       };
37898     } catch (Dali::DaliException e) {
37899       {
37900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37901       };
37902     } catch (...) {
37903       {
37904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37905       };
37906     }
37907   }
37908
37909 }
37910
37911
37912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37913   int jresult ;
37914   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37915   Dali::Layer::Behavior result;
37916
37917   arg1 = (Dali::Layer *)jarg1;
37918   {
37919     try {
37920       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
37921     } catch (std::out_of_range& e) {
37922       {
37923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37924       };
37925     } catch (std::exception& e) {
37926       {
37927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37928       };
37929     } catch (Dali::DaliException e) {
37930       {
37931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37932       };
37933     } catch (...) {
37934       {
37935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37936       };
37937     }
37938   }
37939
37940   jresult = (int)result;
37941   return jresult;
37942 }
37943
37944
37945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37946   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37947   bool arg2 ;
37948
37949   arg1 = (Dali::Layer *)jarg1;
37950   arg2 = jarg2 ? true : false;
37951   {
37952     try {
37953       (arg1)->SetClipping(arg2);
37954     } catch (std::out_of_range& e) {
37955       {
37956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37957       };
37958     } catch (std::exception& e) {
37959       {
37960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37961       };
37962     } catch (Dali::DaliException e) {
37963       {
37964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37965       };
37966     } catch (...) {
37967       {
37968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37969       };
37970     }
37971   }
37972
37973 }
37974
37975
37976 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37977   unsigned int jresult ;
37978   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37979   bool result;
37980
37981   arg1 = (Dali::Layer *)jarg1;
37982   {
37983     try {
37984       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
37985     } catch (std::out_of_range& e) {
37986       {
37987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37988       };
37989     } catch (std::exception& e) {
37990       {
37991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37992       };
37993     } catch (Dali::DaliException e) {
37994       {
37995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37996       };
37997     } catch (...) {
37998       {
37999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38000       };
38001     }
38002   }
38003
38004   jresult = result;
38005   return jresult;
38006 }
38007
38008
38009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
38010   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38011   int arg2 ;
38012   int arg3 ;
38013   int arg4 ;
38014   int arg5 ;
38015
38016   arg1 = (Dali::Layer *)jarg1;
38017   arg2 = (int)jarg2;
38018   arg3 = (int)jarg3;
38019   arg4 = (int)jarg4;
38020   arg5 = (int)jarg5;
38021   {
38022     try {
38023       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
38024     } catch (std::out_of_range& e) {
38025       {
38026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38027       };
38028     } catch (std::exception& e) {
38029       {
38030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38031       };
38032     } catch (Dali::DaliException e) {
38033       {
38034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38035       };
38036     } catch (...) {
38037       {
38038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38039       };
38040     }
38041   }
38042
38043 }
38044
38045
38046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
38047   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38048   Dali::ClippingBox arg2 ;
38049   Dali::ClippingBox *argp2 ;
38050
38051   arg1 = (Dali::Layer *)jarg1;
38052   argp2 = (Dali::ClippingBox *)jarg2;
38053   if (!argp2) {
38054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
38055     return ;
38056   }
38057   arg2 = *argp2;
38058   {
38059     try {
38060       (arg1)->SetClippingBox(arg2);
38061     } catch (std::out_of_range& e) {
38062       {
38063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38064       };
38065     } catch (std::exception& e) {
38066       {
38067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38068       };
38069     } catch (Dali::DaliException e) {
38070       {
38071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38072       };
38073     } catch (...) {
38074       {
38075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38076       };
38077     }
38078   }
38079
38080 }
38081
38082
38083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
38084   void * jresult ;
38085   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38086   Dali::ClippingBox result;
38087
38088   arg1 = (Dali::Layer *)jarg1;
38089   {
38090     try {
38091       result = ((Dali::Layer const *)arg1)->GetClippingBox();
38092     } catch (std::out_of_range& e) {
38093       {
38094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38095       };
38096     } catch (std::exception& e) {
38097       {
38098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38099       };
38100     } catch (Dali::DaliException e) {
38101       {
38102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38103       };
38104     } catch (...) {
38105       {
38106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38107       };
38108     }
38109   }
38110
38111   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
38112   return jresult;
38113 }
38114
38115
38116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
38117   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38118   bool arg2 ;
38119
38120   arg1 = (Dali::Layer *)jarg1;
38121   arg2 = jarg2 ? true : false;
38122   {
38123     try {
38124       (arg1)->SetDepthTestDisabled(arg2);
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 unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
38148   unsigned int jresult ;
38149   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38150   bool result;
38151
38152   arg1 = (Dali::Layer *)jarg1;
38153   {
38154     try {
38155       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
38156     } catch (std::out_of_range& e) {
38157       {
38158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38159       };
38160     } catch (std::exception& e) {
38161       {
38162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38163       };
38164     } catch (Dali::DaliException e) {
38165       {
38166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38167       };
38168     } catch (...) {
38169       {
38170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38171       };
38172     }
38173   }
38174
38175   jresult = result;
38176   return jresult;
38177 }
38178
38179
38180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
38181   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38182   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
38183
38184   arg1 = (Dali::Layer *)jarg1;
38185   arg2 = (Dali::Layer::SortFunctionType)jarg2;
38186   {
38187     try {
38188       (arg1)->SetSortFunction(arg2);
38189     } catch (std::out_of_range& e) {
38190       {
38191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38192       };
38193     } catch (std::exception& e) {
38194       {
38195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38196       };
38197     } catch (Dali::DaliException e) {
38198       {
38199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38200       };
38201     } catch (...) {
38202       {
38203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38204       };
38205     }
38206   }
38207
38208 }
38209
38210
38211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
38212   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38213   bool arg2 ;
38214
38215   arg1 = (Dali::Layer *)jarg1;
38216   arg2 = jarg2 ? true : false;
38217   {
38218     try {
38219       (arg1)->SetTouchConsumed(arg2);
38220     } catch (std::out_of_range& e) {
38221       {
38222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38223       };
38224     } catch (std::exception& e) {
38225       {
38226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38227       };
38228     } catch (Dali::DaliException e) {
38229       {
38230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38231       };
38232     } catch (...) {
38233       {
38234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38235       };
38236     }
38237   }
38238
38239 }
38240
38241
38242 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38243   unsigned int jresult ;
38244   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38245   bool result;
38246
38247   arg1 = (Dali::Layer *)jarg1;
38248   {
38249     try {
38250       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
38251     } catch (std::out_of_range& e) {
38252       {
38253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38254       };
38255     } catch (std::exception& e) {
38256       {
38257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38258       };
38259     } catch (Dali::DaliException e) {
38260       {
38261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38262       };
38263     } catch (...) {
38264       {
38265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38266       };
38267     }
38268   }
38269
38270   jresult = result;
38271   return jresult;
38272 }
38273
38274
38275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38276   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38277   bool arg2 ;
38278
38279   arg1 = (Dali::Layer *)jarg1;
38280   arg2 = jarg2 ? true : false;
38281   {
38282     try {
38283       (arg1)->SetHoverConsumed(arg2);
38284     } catch (std::out_of_range& e) {
38285       {
38286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38287       };
38288     } catch (std::exception& e) {
38289       {
38290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38291       };
38292     } catch (Dali::DaliException e) {
38293       {
38294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38295       };
38296     } catch (...) {
38297       {
38298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38299       };
38300     }
38301   }
38302
38303 }
38304
38305
38306 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38307   unsigned int jresult ;
38308   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38309   bool result;
38310
38311   arg1 = (Dali::Layer *)jarg1;
38312   {
38313     try {
38314       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
38315     } catch (std::out_of_range& e) {
38316       {
38317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38318       };
38319     } catch (std::exception& e) {
38320       {
38321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38322       };
38323     } catch (Dali::DaliException e) {
38324       {
38325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38326       };
38327     } catch (...) {
38328       {
38329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38330       };
38331     }
38332   }
38333
38334   jresult = result;
38335   return jresult;
38336 }
38337
38338
38339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
38340   void * jresult ;
38341   Dali::Vector4 *result = 0 ;
38342
38343   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
38344   jresult = (void *)result;
38345   return jresult;
38346 }
38347
38348
38349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
38350   void * jresult ;
38351   Dali::Vector4 *result = 0 ;
38352
38353   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
38354   jresult = (void *)result;
38355   return jresult;
38356 }
38357
38358
38359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
38360   void * jresult ;
38361   Dali::Stage *result = 0 ;
38362
38363   {
38364     try {
38365       result = (Dali::Stage *)new Dali::Stage();
38366     } catch (std::out_of_range& e) {
38367       {
38368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38369       };
38370     } catch (std::exception& e) {
38371       {
38372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38373       };
38374     } catch (Dali::DaliException e) {
38375       {
38376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38377       };
38378     } catch (...) {
38379       {
38380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38381       };
38382     }
38383   }
38384
38385   jresult = (void *)result;
38386   return jresult;
38387 }
38388
38389
38390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38391   void * jresult ;
38392   Dali::Stage result;
38393
38394   {
38395     try {
38396       result = Dali::Stage::GetCurrent();
38397     } catch (std::out_of_range& e) {
38398       {
38399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38400       };
38401     } catch (std::exception& e) {
38402       {
38403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38404       };
38405     } catch (Dali::DaliException e) {
38406       {
38407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38408       };
38409     } catch (...) {
38410       {
38411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38412       };
38413     }
38414   }
38415
38416   jresult = new Dali::Stage((const Dali::Stage &)result);
38417   return jresult;
38418 }
38419
38420
38421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38422   unsigned int jresult ;
38423   bool result;
38424
38425   {
38426     try {
38427       result = (bool)Dali::Stage::IsInstalled();
38428     } catch (std::out_of_range& e) {
38429       {
38430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38431       };
38432     } catch (std::exception& e) {
38433       {
38434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38435       };
38436     } catch (Dali::DaliException e) {
38437       {
38438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38439       };
38440     } catch (...) {
38441       {
38442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38443       };
38444     }
38445   }
38446
38447   jresult = result;
38448   return jresult;
38449 }
38450
38451
38452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38453   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38454
38455   arg1 = (Dali::Stage *)jarg1;
38456   {
38457     try {
38458       delete arg1;
38459     } catch (std::out_of_range& e) {
38460       {
38461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38462       };
38463     } catch (std::exception& e) {
38464       {
38465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38466       };
38467     } catch (Dali::DaliException e) {
38468       {
38469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38470       };
38471     } catch (...) {
38472       {
38473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38474       };
38475     }
38476   }
38477
38478 }
38479
38480
38481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38482   void * jresult ;
38483   Dali::Stage *arg1 = 0 ;
38484   Dali::Stage *result = 0 ;
38485
38486   arg1 = (Dali::Stage *)jarg1;
38487   if (!arg1) {
38488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38489     return 0;
38490   }
38491   {
38492     try {
38493       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
38494     } catch (std::out_of_range& e) {
38495       {
38496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38497       };
38498     } catch (std::exception& e) {
38499       {
38500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38501       };
38502     } catch (Dali::DaliException e) {
38503       {
38504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38505       };
38506     } catch (...) {
38507       {
38508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38509       };
38510     }
38511   }
38512
38513   jresult = (void *)result;
38514   return jresult;
38515 }
38516
38517
38518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
38519   void * jresult ;
38520   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38521   Dali::Stage *arg2 = 0 ;
38522   Dali::Stage *result = 0 ;
38523
38524   arg1 = (Dali::Stage *)jarg1;
38525   arg2 = (Dali::Stage *)jarg2;
38526   if (!arg2) {
38527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38528     return 0;
38529   }
38530   {
38531     try {
38532       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
38533     } catch (std::out_of_range& e) {
38534       {
38535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38536       };
38537     } catch (std::exception& e) {
38538       {
38539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38540       };
38541     } catch (Dali::DaliException e) {
38542       {
38543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38544       };
38545     } catch (...) {
38546       {
38547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38548       };
38549     }
38550   }
38551
38552   jresult = (void *)result;
38553   return jresult;
38554 }
38555
38556
38557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
38558   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38559   Dali::Actor *arg2 = 0 ;
38560
38561   arg1 = (Dali::Stage *)jarg1;
38562   arg2 = (Dali::Actor *)jarg2;
38563   if (!arg2) {
38564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38565     return ;
38566   }
38567   {
38568     try {
38569       (arg1)->Add(*arg2);
38570     } catch (std::out_of_range& e) {
38571       {
38572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38573       };
38574     } catch (std::exception& e) {
38575       {
38576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38577       };
38578     } catch (Dali::DaliException e) {
38579       {
38580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38581       };
38582     } catch (...) {
38583       {
38584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38585       };
38586     }
38587   }
38588
38589 }
38590
38591
38592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38593   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38594   Dali::Actor *arg2 = 0 ;
38595
38596   arg1 = (Dali::Stage *)jarg1;
38597   arg2 = (Dali::Actor *)jarg2;
38598   if (!arg2) {
38599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38600     return ;
38601   }
38602   {
38603     try {
38604       (arg1)->Remove(*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_GetSize(void * jarg1) {
38628   void * jresult ;
38629   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38630   Dali::Vector2 result;
38631
38632   arg1 = (Dali::Stage *)jarg1;
38633   {
38634     try {
38635       result = ((Dali::Stage const *)arg1)->GetSize();
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 = new Dali::Vector2((const Dali::Vector2 &)result);
38656   return jresult;
38657 }
38658
38659
38660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38661   void * jresult ;
38662   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38663   Dali::RenderTaskList result;
38664
38665   arg1 = (Dali::Stage *)jarg1;
38666   {
38667     try {
38668       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
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 = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38689   return jresult;
38690 }
38691
38692
38693 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38694   unsigned int jresult ;
38695   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38696   unsigned int result;
38697
38698   arg1 = (Dali::Stage *)jarg1;
38699   {
38700     try {
38701       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
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 = result;
38722   return jresult;
38723 }
38724
38725
38726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38727   void * jresult ;
38728   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38729   unsigned int arg2 ;
38730   Dali::Layer result;
38731
38732   arg1 = (Dali::Stage *)jarg1;
38733   arg2 = (unsigned int)jarg2;
38734   {
38735     try {
38736       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38737     } catch (std::out_of_range& e) {
38738       {
38739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38740       };
38741     } catch (std::exception& e) {
38742       {
38743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38744       };
38745     } catch (Dali::DaliException e) {
38746       {
38747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38748       };
38749     } catch (...) {
38750       {
38751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38752       };
38753     }
38754   }
38755
38756   jresult = new Dali::Layer((const Dali::Layer &)result);
38757   return jresult;
38758 }
38759
38760
38761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38762   void * jresult ;
38763   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38764   Dali::Layer result;
38765
38766   arg1 = (Dali::Stage *)jarg1;
38767   {
38768     try {
38769       result = ((Dali::Stage const *)arg1)->GetRootLayer();
38770     } catch (std::out_of_range& e) {
38771       {
38772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38773       };
38774     } catch (std::exception& e) {
38775       {
38776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38777       };
38778     } catch (Dali::DaliException e) {
38779       {
38780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38781       };
38782     } catch (...) {
38783       {
38784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38785       };
38786     }
38787   }
38788
38789   jresult = new Dali::Layer((const Dali::Layer &)result);
38790   return jresult;
38791 }
38792
38793
38794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38795   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38796   Dali::Vector4 arg2 ;
38797   Dali::Vector4 *argp2 ;
38798
38799   arg1 = (Dali::Stage *)jarg1;
38800   argp2 = (Dali::Vector4 *)jarg2;
38801   if (!argp2) {
38802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38803     return ;
38804   }
38805   arg2 = *argp2;
38806   {
38807     try {
38808       (arg1)->SetBackgroundColor(arg2);
38809     } catch (std::out_of_range& e) {
38810       {
38811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38812       };
38813     } catch (std::exception& e) {
38814       {
38815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38816       };
38817     } catch (Dali::DaliException e) {
38818       {
38819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38820       };
38821     } catch (...) {
38822       {
38823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38824       };
38825     }
38826   }
38827
38828 }
38829
38830
38831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38832   void * jresult ;
38833   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38834   Dali::Vector4 result;
38835
38836   arg1 = (Dali::Stage *)jarg1;
38837   {
38838     try {
38839       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38840     } catch (std::out_of_range& e) {
38841       {
38842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38843       };
38844     } catch (std::exception& e) {
38845       {
38846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38847       };
38848     } catch (Dali::DaliException e) {
38849       {
38850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38851       };
38852     } catch (...) {
38853       {
38854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38855       };
38856     }
38857   }
38858
38859   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38860   return jresult;
38861 }
38862
38863
38864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38865   void * jresult ;
38866   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38867   Dali::Vector2 result;
38868
38869   arg1 = (Dali::Stage *)jarg1;
38870   {
38871     try {
38872       result = ((Dali::Stage const *)arg1)->GetDpi();
38873     } catch (std::out_of_range& e) {
38874       {
38875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38876       };
38877     } catch (std::exception& e) {
38878       {
38879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38880       };
38881     } catch (Dali::DaliException e) {
38882       {
38883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38884       };
38885     } catch (...) {
38886       {
38887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38888       };
38889     }
38890   }
38891
38892   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38893   return jresult;
38894 }
38895
38896
38897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38898   void * jresult ;
38899   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38900   Dali::ObjectRegistry result;
38901
38902   arg1 = (Dali::Stage *)jarg1;
38903   {
38904     try {
38905       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
38906     } catch (std::out_of_range& e) {
38907       {
38908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38909       };
38910     } catch (std::exception& e) {
38911       {
38912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38913       };
38914     } catch (Dali::DaliException e) {
38915       {
38916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38917       };
38918     } catch (...) {
38919       {
38920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38921       };
38922     }
38923   }
38924
38925   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
38926   return jresult;
38927 }
38928
38929
38930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38931   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38932   float arg2 ;
38933
38934   arg1 = (Dali::Stage *)jarg1;
38935   arg2 = (float)jarg2;
38936   {
38937     try {
38938       (arg1)->KeepRendering(arg2);
38939     } catch (std::out_of_range& e) {
38940       {
38941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38942       };
38943     } catch (std::exception& e) {
38944       {
38945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38946       };
38947     } catch (Dali::DaliException e) {
38948       {
38949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38950       };
38951     } catch (...) {
38952       {
38953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38954       };
38955     }
38956   }
38957
38958 }
38959
38960
38961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38962   void * jresult ;
38963   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38964   Dali::Stage::KeyEventSignalType *result = 0 ;
38965
38966   arg1 = (Dali::Stage *)jarg1;
38967   {
38968     try {
38969       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38970     } catch (std::out_of_range& e) {
38971       {
38972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38973       };
38974     } catch (std::exception& e) {
38975       {
38976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38977       };
38978     } catch (Dali::DaliException e) {
38979       {
38980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38981       };
38982     } catch (...) {
38983       {
38984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38985       };
38986     }
38987   }
38988
38989   jresult = (void *)result;
38990   return jresult;
38991 }
38992
38993
38994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38995   void * jresult ;
38996   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38997   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38998
38999   arg1 = (Dali::Stage *)jarg1;
39000   {
39001     try {
39002       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
39003     } catch (std::out_of_range& e) {
39004       {
39005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39006       };
39007     } catch (std::exception& e) {
39008       {
39009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39010       };
39011     } catch (Dali::DaliException e) {
39012       {
39013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39014       };
39015     } catch (...) {
39016       {
39017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39018       };
39019     }
39020   }
39021
39022   jresult = (void *)result;
39023   return jresult;
39024 }
39025
39026
39027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
39028   void * jresult ;
39029   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39030   Dali::Stage::TouchSignalType *result = 0 ;
39031
39032   arg1 = (Dali::Stage *)jarg1;
39033   {
39034     try {
39035       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
39036     } catch (std::out_of_range& e) {
39037       {
39038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39039       };
39040     } catch (std::exception& e) {
39041       {
39042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39043       };
39044     } catch (Dali::DaliException e) {
39045       {
39046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39047       };
39048     } catch (...) {
39049       {
39050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39051       };
39052     }
39053   }
39054
39055   jresult = (void *)result;
39056   return jresult;
39057 }
39058
39059
39060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
39061   void * jresult ;
39062   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39063   Dali::Stage::WheelEventSignalType *result = 0 ;
39064
39065   arg1 = (Dali::Stage *)jarg1;
39066   {
39067     try {
39068       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
39069     } catch (std::out_of_range& e) {
39070       {
39071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39072       };
39073     } catch (std::exception& e) {
39074       {
39075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39076       };
39077     } catch (Dali::DaliException e) {
39078       {
39079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39080       };
39081     } catch (...) {
39082       {
39083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39084       };
39085     }
39086   }
39087
39088   jresult = (void *)result;
39089   return jresult;
39090 }
39091
39092
39093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
39094   void * jresult ;
39095   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39096   Dali::Stage::ContextStatusSignal *result = 0 ;
39097
39098   arg1 = (Dali::Stage *)jarg1;
39099   {
39100     try {
39101       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
39102     } catch (std::out_of_range& e) {
39103       {
39104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39105       };
39106     } catch (std::exception& e) {
39107       {
39108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39109       };
39110     } catch (Dali::DaliException e) {
39111       {
39112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39113       };
39114     } catch (...) {
39115       {
39116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39117       };
39118     }
39119   }
39120
39121   jresult = (void *)result;
39122   return jresult;
39123 }
39124
39125
39126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
39127   void * jresult ;
39128   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39129   Dali::Stage::ContextStatusSignal *result = 0 ;
39130
39131   arg1 = (Dali::Stage *)jarg1;
39132   {
39133     try {
39134       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
39135     } catch (std::out_of_range& e) {
39136       {
39137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39138       };
39139     } catch (std::exception& e) {
39140       {
39141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39142       };
39143     } catch (Dali::DaliException e) {
39144       {
39145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39146       };
39147     } catch (...) {
39148       {
39149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39150       };
39151     }
39152   }
39153
39154   jresult = (void *)result;
39155   return jresult;
39156 }
39157
39158
39159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
39160   void * jresult ;
39161   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39162   Dali::Stage::SceneCreatedSignalType *result = 0 ;
39163
39164   arg1 = (Dali::Stage *)jarg1;
39165   {
39166     try {
39167       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
39168     } catch (std::out_of_range& e) {
39169       {
39170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39171       };
39172     } catch (std::exception& e) {
39173       {
39174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39175       };
39176     } catch (Dali::DaliException e) {
39177       {
39178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39179       };
39180     } catch (...) {
39181       {
39182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39183       };
39184     }
39185   }
39186
39187   jresult = (void *)result;
39188   return jresult;
39189 }
39190
39191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
39192   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39193   Dali::DevelStage::Rendering arg2 ;
39194
39195   arg1 = (Dali::Stage *)jarg1;
39196   arg2 = (Dali::DevelStage::Rendering)jarg2;
39197   {
39198     try {
39199       DevelStage::SetRenderingBehavior(*arg1,arg2);
39200     } catch (std::out_of_range& e) {
39201       {
39202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39203       };
39204     } catch (std::exception& e) {
39205       {
39206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39207       };
39208     } catch (Dali::DaliException e) {
39209       {
39210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39211       };
39212     } catch (...) {
39213       {
39214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39215       };
39216     }
39217   }
39218
39219 }
39220
39221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
39222
39223   int jresult ;
39224   int result ;
39225   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39226
39227   arg1 = (Dali::Stage *)jarg1;
39228   {
39229     try {
39230       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
39231     } catch (std::out_of_range& e) {
39232       {
39233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39234       };
39235     } catch (std::exception& e) {
39236       {
39237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39238       };
39239     } catch (Dali::DaliException e) {
39240       {
39241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39242       };
39243     } catch (...) {
39244       {
39245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39246       };
39247     }
39248   }
39249
39250   jresult = result;
39251   return jresult;
39252 }
39253
39254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
39255   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39256
39257   arg1 = (Dali::RelayoutContainer *)jarg1;
39258   {
39259     try {
39260       delete arg1;
39261     } catch (std::out_of_range& e) {
39262       {
39263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39264       };
39265     } catch (std::exception& e) {
39266       {
39267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39268       };
39269     } catch (Dali::DaliException e) {
39270       {
39271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39272       };
39273     } catch (...) {
39274       {
39275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39276       };
39277     }
39278   }
39279
39280 }
39281
39282
39283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
39284   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39285   Dali::Actor *arg2 = 0 ;
39286   Dali::Vector2 *arg3 = 0 ;
39287
39288   arg1 = (Dali::RelayoutContainer *)jarg1;
39289   arg2 = (Dali::Actor *)jarg2;
39290   if (!arg2) {
39291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39292     return ;
39293   }
39294   arg3 = (Dali::Vector2 *)jarg3;
39295   if (!arg3) {
39296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39297     return ;
39298   }
39299   {
39300     try {
39301       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
39302     } catch (std::out_of_range& e) {
39303       {
39304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39305       };
39306     } catch (std::exception& e) {
39307       {
39308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39309       };
39310     } catch (Dali::DaliException e) {
39311       {
39312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39313       };
39314     } catch (...) {
39315       {
39316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39317       };
39318     }
39319   }
39320
39321 }
39322
39323
39324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
39325   void * jresult ;
39326   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39327   Dali::CustomActor result;
39328
39329   arg1 = (Dali::CustomActorImpl *)jarg1;
39330   {
39331     try {
39332       result = ((Dali::CustomActorImpl const *)arg1)->Self();
39333     } catch (std::out_of_range& e) {
39334       {
39335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39336       };
39337     } catch (std::exception& e) {
39338       {
39339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39340       };
39341     } catch (Dali::DaliException e) {
39342       {
39343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39344       };
39345     } catch (...) {
39346       {
39347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39348       };
39349     }
39350   }
39351
39352   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39353   return jresult;
39354 }
39355
39356
39357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
39358   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39359   int arg2 ;
39360
39361   arg1 = (Dali::CustomActorImpl *)jarg1;
39362   arg2 = (int)jarg2;
39363   {
39364     try {
39365       (arg1)->OnStageConnection(arg2);
39366     } catch (std::out_of_range& e) {
39367       {
39368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39369       };
39370     } catch (std::exception& e) {
39371       {
39372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39373       };
39374     } catch (Dali::DaliException e) {
39375       {
39376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39377       };
39378     } catch (...) {
39379       {
39380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39381       };
39382     }
39383   }
39384
39385 }
39386
39387
39388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
39389   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39390
39391   arg1 = (Dali::CustomActorImpl *)jarg1;
39392   {
39393     try {
39394       (arg1)->OnStageDisconnection();
39395     } catch (std::out_of_range& e) {
39396       {
39397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39398       };
39399     } catch (std::exception& e) {
39400       {
39401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39402       };
39403     } catch (Dali::DaliException e) {
39404       {
39405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39406       };
39407     } catch (...) {
39408       {
39409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39410       };
39411     }
39412   }
39413
39414 }
39415
39416
39417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39418   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39419   Dali::Actor *arg2 = 0 ;
39420
39421   arg1 = (Dali::CustomActorImpl *)jarg1;
39422   arg2 = (Dali::Actor *)jarg2;
39423   if (!arg2) {
39424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39425     return ;
39426   }
39427   {
39428     try {
39429       (arg1)->OnChildAdd(*arg2);
39430     } catch (std::out_of_range& e) {
39431       {
39432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39433       };
39434     } catch (std::exception& e) {
39435       {
39436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39437       };
39438     } catch (Dali::DaliException e) {
39439       {
39440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39441       };
39442     } catch (...) {
39443       {
39444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39445       };
39446     }
39447   }
39448
39449 }
39450
39451
39452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39453   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39454   Dali::Actor *arg2 = 0 ;
39455
39456   arg1 = (Dali::CustomActorImpl *)jarg1;
39457   arg2 = (Dali::Actor *)jarg2;
39458   if (!arg2) {
39459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39460     return ;
39461   }
39462   {
39463     try {
39464       (arg1)->OnChildRemove(*arg2);
39465     } catch (std::out_of_range& e) {
39466       {
39467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39468       };
39469     } catch (std::exception& e) {
39470       {
39471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39472       };
39473     } catch (Dali::DaliException e) {
39474       {
39475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39476       };
39477     } catch (...) {
39478       {
39479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39480       };
39481     }
39482   }
39483
39484 }
39485
39486
39487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39488   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39489   Dali::Property::Index arg2 ;
39490   Dali::Property::Value arg3 ;
39491   Dali::Property::Value *argp3 ;
39492
39493   arg1 = (Dali::CustomActorImpl *)jarg1;
39494   arg2 = (Dali::Property::Index)jarg2;
39495   argp3 = (Dali::Property::Value *)jarg3;
39496   if (!argp3) {
39497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39498     return ;
39499   }
39500   arg3 = *argp3;
39501   {
39502     try {
39503       (arg1)->OnPropertySet(arg2,arg3);
39504     } catch (std::out_of_range& e) {
39505       {
39506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39507       };
39508     } catch (std::exception& e) {
39509       {
39510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39511       };
39512     } catch (Dali::DaliException e) {
39513       {
39514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39515       };
39516     } catch (...) {
39517       {
39518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39519       };
39520     }
39521   }
39522
39523 }
39524
39525
39526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39527   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39528   Dali::Vector3 *arg2 = 0 ;
39529
39530   arg1 = (Dali::CustomActorImpl *)jarg1;
39531   arg2 = (Dali::Vector3 *)jarg2;
39532   if (!arg2) {
39533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39534     return ;
39535   }
39536   {
39537     try {
39538       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39539     } catch (std::out_of_range& e) {
39540       {
39541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39542       };
39543     } catch (std::exception& e) {
39544       {
39545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39546       };
39547     } catch (Dali::DaliException e) {
39548       {
39549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39550       };
39551     } catch (...) {
39552       {
39553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39554       };
39555     }
39556   }
39557
39558 }
39559
39560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39561   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39562   Dali::Animation *arg2 = 0 ;
39563   Dali::Vector3 *arg3 = 0 ;
39564
39565   arg1 = (Dali::CustomActorImpl *)jarg1;
39566   arg2 = (Dali::Animation *)jarg2;
39567   if (!arg2) {
39568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39569     return ;
39570   }
39571   arg3 = (Dali::Vector3 *)jarg3;
39572   if (!arg3) {
39573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39574     return ;
39575   }
39576   {
39577     try {
39578       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39579     } catch (std::out_of_range& e) {
39580       {
39581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39582       };
39583     } catch (std::exception& e) {
39584       {
39585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39586       };
39587     } catch (Dali::DaliException e) {
39588       {
39589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39590       };
39591     } catch (...) {
39592       {
39593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39594       };
39595     }
39596   }
39597
39598 }
39599
39600
39601 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39602   unsigned int jresult ;
39603   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39604   Dali::TouchEvent *arg2 = 0 ;
39605   bool result;
39606
39607   arg1 = (Dali::CustomActorImpl *)jarg1;
39608   arg2 = (Dali::TouchEvent *)jarg2;
39609   if (!arg2) {
39610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39611     return 0;
39612   }
39613   {
39614     try {
39615       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
39616     } catch (std::out_of_range& e) {
39617       {
39618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39619       };
39620     } catch (std::exception& e) {
39621       {
39622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39623       };
39624     } catch (Dali::DaliException e) {
39625       {
39626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39627       };
39628     } catch (...) {
39629       {
39630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39631       };
39632     }
39633   }
39634
39635   jresult = result;
39636   return jresult;
39637 }
39638
39639
39640 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39641   unsigned int jresult ;
39642   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39643   Dali::HoverEvent *arg2 = 0 ;
39644   bool result;
39645
39646   arg1 = (Dali::CustomActorImpl *)jarg1;
39647   arg2 = (Dali::HoverEvent *)jarg2;
39648   if (!arg2) {
39649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39650     return 0;
39651   }
39652   {
39653     try {
39654       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39655     } catch (std::out_of_range& e) {
39656       {
39657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39658       };
39659     } catch (std::exception& e) {
39660       {
39661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39662       };
39663     } catch (Dali::DaliException e) {
39664       {
39665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39666       };
39667     } catch (...) {
39668       {
39669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39670       };
39671     }
39672   }
39673
39674   jresult = result;
39675   return jresult;
39676 }
39677
39678
39679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39680   unsigned int jresult ;
39681   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39682   Dali::KeyEvent *arg2 = 0 ;
39683   bool result;
39684
39685   arg1 = (Dali::CustomActorImpl *)jarg1;
39686   arg2 = (Dali::KeyEvent *)jarg2;
39687   if (!arg2) {
39688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39689     return 0;
39690   }
39691   {
39692     try {
39693       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39694     } catch (std::out_of_range& e) {
39695       {
39696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39697       };
39698     } catch (std::exception& e) {
39699       {
39700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39701       };
39702     } catch (Dali::DaliException e) {
39703       {
39704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39705       };
39706     } catch (...) {
39707       {
39708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39709       };
39710     }
39711   }
39712
39713   jresult = result;
39714   return jresult;
39715 }
39716
39717
39718 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39719   unsigned int jresult ;
39720   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39721   Dali::WheelEvent *arg2 = 0 ;
39722   bool result;
39723
39724   arg1 = (Dali::CustomActorImpl *)jarg1;
39725   arg2 = (Dali::WheelEvent *)jarg2;
39726   if (!arg2) {
39727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39728     return 0;
39729   }
39730   {
39731     try {
39732       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39733     } catch (std::out_of_range& e) {
39734       {
39735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39736       };
39737     } catch (std::exception& e) {
39738       {
39739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39740       };
39741     } catch (Dali::DaliException e) {
39742       {
39743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39744       };
39745     } catch (...) {
39746       {
39747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39748       };
39749     }
39750   }
39751
39752   jresult = result;
39753   return jresult;
39754 }
39755
39756
39757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39758   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39759   Dali::Vector2 *arg2 = 0 ;
39760   Dali::RelayoutContainer *arg3 = 0 ;
39761
39762   arg1 = (Dali::CustomActorImpl *)jarg1;
39763   arg2 = (Dali::Vector2 *)jarg2;
39764   if (!arg2) {
39765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39766     return ;
39767   }
39768   arg3 = (Dali::RelayoutContainer *)jarg3;
39769   if (!arg3) {
39770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39771     return ;
39772   }
39773   {
39774     try {
39775       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39776     } catch (std::out_of_range& e) {
39777       {
39778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39779       };
39780     } catch (std::exception& e) {
39781       {
39782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39783       };
39784     } catch (Dali::DaliException e) {
39785       {
39786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39787       };
39788     } catch (...) {
39789       {
39790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39791       };
39792     }
39793   }
39794
39795 }
39796
39797
39798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39799   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39800   Dali::ResizePolicy::Type arg2 ;
39801   Dali::Dimension::Type arg3 ;
39802
39803   arg1 = (Dali::CustomActorImpl *)jarg1;
39804   arg2 = (Dali::ResizePolicy::Type)jarg2;
39805   arg3 = (Dali::Dimension::Type)jarg3;
39806   {
39807     try {
39808       (arg1)->OnSetResizePolicy(arg2,arg3);
39809     } catch (std::out_of_range& e) {
39810       {
39811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39812       };
39813     } catch (std::exception& e) {
39814       {
39815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39816       };
39817     } catch (Dali::DaliException e) {
39818       {
39819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39820       };
39821     } catch (...) {
39822       {
39823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39824       };
39825     }
39826   }
39827
39828 }
39829
39830
39831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39832   void * jresult ;
39833   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39834   Dali::Vector3 result;
39835
39836   arg1 = (Dali::CustomActorImpl *)jarg1;
39837   {
39838     try {
39839       result = (arg1)->GetNaturalSize();
39840     } catch (std::out_of_range& e) {
39841       {
39842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39843       };
39844     } catch (std::exception& e) {
39845       {
39846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39847       };
39848     } catch (Dali::DaliException e) {
39849       {
39850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39851       };
39852     } catch (...) {
39853       {
39854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39855       };
39856     }
39857   }
39858
39859   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39860   return jresult;
39861 }
39862
39863
39864 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39865   float jresult ;
39866   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39867   Dali::Actor *arg2 = 0 ;
39868   Dali::Dimension::Type arg3 ;
39869   float result;
39870
39871   arg1 = (Dali::CustomActorImpl *)jarg1;
39872   arg2 = (Dali::Actor *)jarg2;
39873   if (!arg2) {
39874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39875     return 0;
39876   }
39877   arg3 = (Dali::Dimension::Type)jarg3;
39878   {
39879     try {
39880       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
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 float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39906   float jresult ;
39907   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39908   float arg2 ;
39909   float result;
39910
39911   arg1 = (Dali::CustomActorImpl *)jarg1;
39912   arg2 = (float)jarg2;
39913   {
39914     try {
39915       result = (float)(arg1)->GetHeightForWidth(arg2);
39916     } catch (std::out_of_range& e) {
39917       {
39918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39919       };
39920     } catch (std::exception& e) {
39921       {
39922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39923       };
39924     } catch (Dali::DaliException e) {
39925       {
39926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39927       };
39928     } catch (...) {
39929       {
39930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39931       };
39932     }
39933   }
39934
39935   jresult = result;
39936   return jresult;
39937 }
39938
39939
39940 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39941   float jresult ;
39942   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39943   float arg2 ;
39944   float result;
39945
39946   arg1 = (Dali::CustomActorImpl *)jarg1;
39947   arg2 = (float)jarg2;
39948   {
39949     try {
39950       result = (float)(arg1)->GetWidthForHeight(arg2);
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 = result;
39971   return jresult;
39972 }
39973
39974
39975 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39976   unsigned int jresult ;
39977   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39978   Dali::Dimension::Type arg2 ;
39979   bool result;
39980
39981   arg1 = (Dali::CustomActorImpl *)jarg1;
39982   arg2 = (Dali::Dimension::Type)jarg2;
39983   {
39984     try {
39985       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39986     } catch (std::out_of_range& e) {
39987       {
39988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39989       };
39990     } catch (std::exception& e) {
39991       {
39992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39993       };
39994     } catch (Dali::DaliException e) {
39995       {
39996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39997       };
39998     } catch (...) {
39999       {
40000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40001       };
40002     }
40003   }
40004
40005   jresult = result;
40006   return jresult;
40007 }
40008
40009
40010 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
40011   unsigned int jresult ;
40012   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40013   bool result;
40014
40015   arg1 = (Dali::CustomActorImpl *)jarg1;
40016   {
40017     try {
40018       result = (bool)(arg1)->RelayoutDependentOnChildren();
40019     } catch (std::out_of_range& e) {
40020       {
40021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40022       };
40023     } catch (std::exception& e) {
40024       {
40025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40026       };
40027     } catch (Dali::DaliException e) {
40028       {
40029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40030       };
40031     } catch (...) {
40032       {
40033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40034       };
40035     }
40036   }
40037
40038   jresult = result;
40039   return jresult;
40040 }
40041
40042
40043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
40044   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40045   Dali::Dimension::Type arg2 ;
40046
40047   arg1 = (Dali::CustomActorImpl *)jarg1;
40048   arg2 = (Dali::Dimension::Type)jarg2;
40049   {
40050     try {
40051       (arg1)->OnCalculateRelayoutSize(arg2);
40052     } catch (std::out_of_range& e) {
40053       {
40054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40055       };
40056     } catch (std::exception& e) {
40057       {
40058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40059       };
40060     } catch (Dali::DaliException e) {
40061       {
40062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40063       };
40064     } catch (...) {
40065       {
40066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40067       };
40068     }
40069   }
40070
40071 }
40072
40073
40074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
40075   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40076   float arg2 ;
40077   Dali::Dimension::Type arg3 ;
40078
40079   arg1 = (Dali::CustomActorImpl *)jarg1;
40080   arg2 = (float)jarg2;
40081   arg3 = (Dali::Dimension::Type)jarg3;
40082   {
40083     try {
40084       (arg1)->OnLayoutNegotiated(arg2,arg3);
40085     } catch (std::out_of_range& e) {
40086       {
40087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40088       };
40089     } catch (std::exception& e) {
40090       {
40091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40092       };
40093     } catch (Dali::DaliException e) {
40094       {
40095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40096       };
40097     } catch (...) {
40098       {
40099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40100       };
40101     }
40102   }
40103
40104 }
40105
40106
40107 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
40108   unsigned int jresult ;
40109   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40110   bool result;
40111
40112   arg1 = (Dali::CustomActorImpl *)jarg1;
40113   {
40114     try {
40115       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
40116     } catch (std::out_of_range& e) {
40117       {
40118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40119       };
40120     } catch (std::exception& e) {
40121       {
40122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40123       };
40124     } catch (Dali::DaliException e) {
40125       {
40126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40127       };
40128     } catch (...) {
40129       {
40130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40131       };
40132     }
40133   }
40134
40135   jresult = result;
40136   return jresult;
40137 }
40138
40139
40140 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
40141   unsigned int jresult ;
40142   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40143   bool result;
40144
40145   arg1 = (Dali::CustomActorImpl *)jarg1;
40146   {
40147     try {
40148       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
40149     } catch (std::out_of_range& e) {
40150       {
40151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40152       };
40153     } catch (std::exception& e) {
40154       {
40155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40156       };
40157     } catch (Dali::DaliException e) {
40158       {
40159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40160       };
40161     } catch (...) {
40162       {
40163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40164       };
40165     }
40166   }
40167
40168   jresult = result;
40169   return jresult;
40170 }
40171
40172
40173 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
40174   unsigned int jresult ;
40175   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40176   bool result;
40177
40178   arg1 = (Dali::CustomActorImpl *)jarg1;
40179   {
40180     try {
40181       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
40182     } catch (std::out_of_range& e) {
40183       {
40184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40185       };
40186     } catch (std::exception& e) {
40187       {
40188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40189       };
40190     } catch (Dali::DaliException e) {
40191       {
40192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40193       };
40194     } catch (...) {
40195       {
40196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40197       };
40198     }
40199   }
40200
40201   jresult = result;
40202   return jresult;
40203 }
40204
40205
40206 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
40207   unsigned int jresult ;
40208   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40209   bool result;
40210
40211   arg1 = (Dali::CustomActorImpl *)jarg1;
40212   {
40213     try {
40214       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
40215     } catch (std::out_of_range& e) {
40216       {
40217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40218       };
40219     } catch (std::exception& e) {
40220       {
40221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40222       };
40223     } catch (Dali::DaliException e) {
40224       {
40225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40226       };
40227     } catch (...) {
40228       {
40229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40230       };
40231     }
40232   }
40233
40234   jresult = result;
40235   return jresult;
40236 }
40237
40238
40239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
40240   void * jresult ;
40241   Dali::CustomActor *result = 0 ;
40242
40243   {
40244     try {
40245       result = (Dali::CustomActor *)new Dali::CustomActor();
40246     } catch (std::out_of_range& e) {
40247       {
40248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40249       };
40250     } catch (std::exception& e) {
40251       {
40252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40253       };
40254     } catch (Dali::DaliException e) {
40255       {
40256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40257       };
40258     } catch (...) {
40259       {
40260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40261       };
40262     }
40263   }
40264
40265   jresult = (void *)result;
40266   return jresult;
40267 }
40268
40269
40270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
40271   void * jresult ;
40272   Dali::BaseHandle arg1 ;
40273   Dali::BaseHandle *argp1 ;
40274   Dali::CustomActor result;
40275
40276   argp1 = (Dali::BaseHandle *)jarg1;
40277   if (!argp1) {
40278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40279     return 0;
40280   }
40281   arg1 = *argp1;
40282   {
40283     try {
40284       result = Dali::CustomActor::DownCast(arg1);
40285     } catch (std::out_of_range& e) {
40286       {
40287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40288       };
40289     } catch (std::exception& e) {
40290       {
40291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40292       };
40293     } catch (Dali::DaliException e) {
40294       {
40295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40296       };
40297     } catch (...) {
40298       {
40299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40300       };
40301     }
40302   }
40303
40304   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
40305   return jresult;
40306 }
40307
40308
40309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
40310   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40311
40312   arg1 = (Dali::CustomActor *)jarg1;
40313   {
40314     try {
40315       delete arg1;
40316     } catch (std::out_of_range& e) {
40317       {
40318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40319       };
40320     } catch (std::exception& e) {
40321       {
40322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40323       };
40324     } catch (Dali::DaliException e) {
40325       {
40326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40327       };
40328     } catch (...) {
40329       {
40330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40331       };
40332     }
40333   }
40334
40335 }
40336
40337
40338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
40339   void * jresult ;
40340   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40341   Dali::CustomActorImpl *result = 0 ;
40342
40343   arg1 = (Dali::CustomActor *)jarg1;
40344   {
40345     try {
40346       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
40347     } catch (std::out_of_range& e) {
40348       {
40349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40350       };
40351     } catch (std::exception& e) {
40352       {
40353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40354       };
40355     } catch (Dali::DaliException e) {
40356       {
40357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40358       };
40359     } catch (...) {
40360       {
40361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40362       };
40363     }
40364   }
40365
40366   jresult = (void *)result;
40367   return jresult;
40368 }
40369
40370
40371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
40372   void * jresult ;
40373   Dali::CustomActorImpl *arg1 = 0 ;
40374   Dali::CustomActor *result = 0 ;
40375
40376   arg1 = (Dali::CustomActorImpl *)jarg1;
40377   if (!arg1) {
40378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
40379     return 0;
40380   }
40381   {
40382     try {
40383       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
40384     } catch (std::out_of_range& e) {
40385       {
40386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40387       };
40388     } catch (std::exception& e) {
40389       {
40390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40391       };
40392     } catch (Dali::DaliException e) {
40393       {
40394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40395       };
40396     } catch (...) {
40397       {
40398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40399       };
40400     }
40401   }
40402
40403   jresult = (void *)result;
40404   return jresult;
40405 }
40406
40407
40408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
40409   void * jresult ;
40410   Dali::CustomActor *arg1 = 0 ;
40411   Dali::CustomActor *result = 0 ;
40412
40413   arg1 = (Dali::CustomActor *)jarg1;
40414   if (!arg1) {
40415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40416     return 0;
40417   }
40418   {
40419     try {
40420       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40421     } catch (std::out_of_range& e) {
40422       {
40423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40424       };
40425     } catch (std::exception& e) {
40426       {
40427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40428       };
40429     } catch (Dali::DaliException e) {
40430       {
40431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40432       };
40433     } catch (...) {
40434       {
40435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40436       };
40437     }
40438   }
40439
40440   jresult = (void *)result;
40441   return jresult;
40442 }
40443
40444
40445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40446   void * jresult ;
40447   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40448   Dali::CustomActor *arg2 = 0 ;
40449   Dali::CustomActor *result = 0 ;
40450
40451   arg1 = (Dali::CustomActor *)jarg1;
40452   arg2 = (Dali::CustomActor *)jarg2;
40453   if (!arg2) {
40454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40455     return 0;
40456   }
40457   {
40458     try {
40459       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40460     } catch (std::out_of_range& e) {
40461       {
40462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40463       };
40464     } catch (std::exception& e) {
40465       {
40466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40467       };
40468     } catch (Dali::DaliException e) {
40469       {
40470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40471       };
40472     } catch (...) {
40473       {
40474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40475       };
40476     }
40477   }
40478
40479   jresult = (void *)result;
40480   return jresult;
40481 }
40482
40483
40484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40485   int jresult ;
40486   int result;
40487
40488   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40489   jresult = (int)result;
40490   return jresult;
40491 }
40492
40493
40494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40495   int jresult ;
40496   int result;
40497
40498   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40499   jresult = (int)result;
40500   return jresult;
40501 }
40502
40503
40504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40505   int jresult ;
40506   int result;
40507
40508   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40509   jresult = (int)result;
40510   return jresult;
40511 }
40512
40513
40514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40515   int jresult ;
40516   int result;
40517
40518   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40519   jresult = (int)result;
40520   return jresult;
40521 }
40522
40523
40524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40525   int jresult ;
40526   int result;
40527
40528   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40529   jresult = (int)result;
40530   return jresult;
40531 }
40532
40533
40534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40535   int jresult ;
40536   int result;
40537
40538   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40539   jresult = (int)result;
40540   return jresult;
40541 }
40542
40543
40544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40545   int jresult ;
40546   int result;
40547
40548   result = (int)Dali::PanGestureDetector::Property::PANNING;
40549   jresult = (int)result;
40550   return jresult;
40551 }
40552
40553
40554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40555   void * jresult ;
40556   Dali::PanGestureDetector::Property *result = 0 ;
40557
40558   {
40559     try {
40560       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40561     } catch (std::out_of_range& e) {
40562       {
40563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40564       };
40565     } catch (std::exception& e) {
40566       {
40567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40568       };
40569     } catch (Dali::DaliException e) {
40570       {
40571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40572       };
40573     } catch (...) {
40574       {
40575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40576       };
40577     }
40578   }
40579
40580   jresult = (void *)result;
40581   return jresult;
40582 }
40583
40584
40585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40586   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40587
40588   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40589   {
40590     try {
40591       delete arg1;
40592     } catch (std::out_of_range& e) {
40593       {
40594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40595       };
40596     } catch (std::exception& e) {
40597       {
40598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40599       };
40600     } catch (Dali::DaliException e) {
40601       {
40602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40603       };
40604     } catch (...) {
40605       {
40606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40607       };
40608     }
40609   }
40610
40611 }
40612
40613
40614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40615   void * jresult ;
40616   Dali::Radian *result = 0 ;
40617
40618   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40619   jresult = (void *)result;
40620   return jresult;
40621 }
40622
40623
40624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40625   void * jresult ;
40626   Dali::Radian *result = 0 ;
40627
40628   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40629   jresult = (void *)result;
40630   return jresult;
40631 }
40632
40633
40634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40635   void * jresult ;
40636   Dali::Radian *result = 0 ;
40637
40638   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40639   jresult = (void *)result;
40640   return jresult;
40641 }
40642
40643
40644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40645   void * jresult ;
40646   Dali::Radian *result = 0 ;
40647
40648   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40649   jresult = (void *)result;
40650   return jresult;
40651 }
40652
40653
40654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40655   void * jresult ;
40656   Dali::Radian *result = 0 ;
40657
40658   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40659   jresult = (void *)result;
40660   return jresult;
40661 }
40662
40663
40664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40665   void * jresult ;
40666   Dali::Radian *result = 0 ;
40667
40668   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40669   jresult = (void *)result;
40670   return jresult;
40671 }
40672
40673
40674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40675   void * jresult ;
40676   Dali::Radian *result = 0 ;
40677
40678   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40679   jresult = (void *)result;
40680   return jresult;
40681 }
40682
40683
40684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40685   void * jresult ;
40686   Dali::PanGestureDetector *result = 0 ;
40687
40688   {
40689     try {
40690       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40691     } catch (std::out_of_range& e) {
40692       {
40693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40694       };
40695     } catch (std::exception& e) {
40696       {
40697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40698       };
40699     } catch (Dali::DaliException e) {
40700       {
40701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40702       };
40703     } catch (...) {
40704       {
40705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40706       };
40707     }
40708   }
40709
40710   jresult = (void *)result;
40711   return jresult;
40712 }
40713
40714
40715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40716   void * jresult ;
40717   Dali::PanGestureDetector result;
40718
40719   {
40720     try {
40721       result = Dali::PanGestureDetector::New();
40722     } catch (std::out_of_range& e) {
40723       {
40724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40725       };
40726     } catch (std::exception& e) {
40727       {
40728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40729       };
40730     } catch (Dali::DaliException e) {
40731       {
40732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40733       };
40734     } catch (...) {
40735       {
40736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40737       };
40738     }
40739   }
40740
40741   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40742   return jresult;
40743 }
40744
40745
40746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40747   void * jresult ;
40748   Dali::BaseHandle arg1 ;
40749   Dali::BaseHandle *argp1 ;
40750   Dali::PanGestureDetector result;
40751
40752   argp1 = (Dali::BaseHandle *)jarg1;
40753   if (!argp1) {
40754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40755     return 0;
40756   }
40757   arg1 = *argp1;
40758   {
40759     try {
40760       result = Dali::PanGestureDetector::DownCast(arg1);
40761     } catch (std::out_of_range& e) {
40762       {
40763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40764       };
40765     } catch (std::exception& e) {
40766       {
40767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40768       };
40769     } catch (Dali::DaliException e) {
40770       {
40771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40772       };
40773     } catch (...) {
40774       {
40775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40776       };
40777     }
40778   }
40779
40780   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40781   return jresult;
40782 }
40783
40784
40785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40786   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40787
40788   arg1 = (Dali::PanGestureDetector *)jarg1;
40789   {
40790     try {
40791       delete arg1;
40792     } catch (std::out_of_range& e) {
40793       {
40794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40795       };
40796     } catch (std::exception& e) {
40797       {
40798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40799       };
40800     } catch (Dali::DaliException e) {
40801       {
40802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40803       };
40804     } catch (...) {
40805       {
40806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40807       };
40808     }
40809   }
40810
40811 }
40812
40813
40814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40815   void * jresult ;
40816   Dali::PanGestureDetector *arg1 = 0 ;
40817   Dali::PanGestureDetector *result = 0 ;
40818
40819   arg1 = (Dali::PanGestureDetector *)jarg1;
40820   if (!arg1) {
40821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40822     return 0;
40823   }
40824   {
40825     try {
40826       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40827     } catch (std::out_of_range& e) {
40828       {
40829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40830       };
40831     } catch (std::exception& e) {
40832       {
40833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40834       };
40835     } catch (Dali::DaliException e) {
40836       {
40837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40838       };
40839     } catch (...) {
40840       {
40841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40842       };
40843     }
40844   }
40845
40846   jresult = (void *)result;
40847   return jresult;
40848 }
40849
40850
40851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40852   void * jresult ;
40853   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40854   Dali::PanGestureDetector *arg2 = 0 ;
40855   Dali::PanGestureDetector *result = 0 ;
40856
40857   arg1 = (Dali::PanGestureDetector *)jarg1;
40858   arg2 = (Dali::PanGestureDetector *)jarg2;
40859   if (!arg2) {
40860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40861     return 0;
40862   }
40863   {
40864     try {
40865       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40866     } catch (std::out_of_range& e) {
40867       {
40868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40869       };
40870     } catch (std::exception& e) {
40871       {
40872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40873       };
40874     } catch (Dali::DaliException e) {
40875       {
40876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40877       };
40878     } catch (...) {
40879       {
40880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40881       };
40882     }
40883   }
40884
40885   jresult = (void *)result;
40886   return jresult;
40887 }
40888
40889
40890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40891   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40892   unsigned int arg2 ;
40893
40894   arg1 = (Dali::PanGestureDetector *)jarg1;
40895   arg2 = (unsigned int)jarg2;
40896   {
40897     try {
40898       (arg1)->SetMinimumTouchesRequired(arg2);
40899     } catch (std::out_of_range& e) {
40900       {
40901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40902       };
40903     } catch (std::exception& e) {
40904       {
40905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40906       };
40907     } catch (Dali::DaliException e) {
40908       {
40909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40910       };
40911     } catch (...) {
40912       {
40913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40914       };
40915     }
40916   }
40917
40918 }
40919
40920
40921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40922   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40923   unsigned int arg2 ;
40924
40925   arg1 = (Dali::PanGestureDetector *)jarg1;
40926   arg2 = (unsigned int)jarg2;
40927   {
40928     try {
40929       (arg1)->SetMaximumTouchesRequired(arg2);
40930     } catch (std::out_of_range& e) {
40931       {
40932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40933       };
40934     } catch (std::exception& e) {
40935       {
40936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40937       };
40938     } catch (Dali::DaliException e) {
40939       {
40940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40941       };
40942     } catch (...) {
40943       {
40944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40945       };
40946     }
40947   }
40948
40949 }
40950
40951
40952 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40953   unsigned int jresult ;
40954   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40955   unsigned int result;
40956
40957   arg1 = (Dali::PanGestureDetector *)jarg1;
40958   {
40959     try {
40960       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40961     } catch (std::out_of_range& e) {
40962       {
40963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40964       };
40965     } catch (std::exception& e) {
40966       {
40967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40968       };
40969     } catch (Dali::DaliException e) {
40970       {
40971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40972       };
40973     } catch (...) {
40974       {
40975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40976       };
40977     }
40978   }
40979
40980   jresult = result;
40981   return jresult;
40982 }
40983
40984
40985 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40986   unsigned int jresult ;
40987   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40988   unsigned int result;
40989
40990   arg1 = (Dali::PanGestureDetector *)jarg1;
40991   {
40992     try {
40993       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40994     } catch (std::out_of_range& e) {
40995       {
40996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40997       };
40998     } catch (std::exception& e) {
40999       {
41000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41001       };
41002     } catch (Dali::DaliException e) {
41003       {
41004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41005       };
41006     } catch (...) {
41007       {
41008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41009       };
41010     }
41011   }
41012
41013   jresult = result;
41014   return jresult;
41015 }
41016
41017
41018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
41019   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41020   Dali::Radian arg2 ;
41021   Dali::Radian arg3 ;
41022   Dali::Radian *argp2 ;
41023   Dali::Radian *argp3 ;
41024
41025   arg1 = (Dali::PanGestureDetector *)jarg1;
41026   argp2 = (Dali::Radian *)jarg2;
41027   if (!argp2) {
41028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41029     return ;
41030   }
41031   arg2 = *argp2;
41032   argp3 = (Dali::Radian *)jarg3;
41033   if (!argp3) {
41034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41035     return ;
41036   }
41037   arg3 = *argp3;
41038   {
41039     try {
41040       (arg1)->AddAngle(arg2,arg3);
41041     } catch (std::out_of_range& e) {
41042       {
41043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41044       };
41045     } catch (std::exception& e) {
41046       {
41047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41048       };
41049     } catch (Dali::DaliException e) {
41050       {
41051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41052       };
41053     } catch (...) {
41054       {
41055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41056       };
41057     }
41058   }
41059
41060 }
41061
41062
41063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
41064   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41065   Dali::Radian arg2 ;
41066   Dali::Radian *argp2 ;
41067
41068   arg1 = (Dali::PanGestureDetector *)jarg1;
41069   argp2 = (Dali::Radian *)jarg2;
41070   if (!argp2) {
41071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41072     return ;
41073   }
41074   arg2 = *argp2;
41075   {
41076     try {
41077       (arg1)->AddAngle(arg2);
41078     } catch (std::out_of_range& e) {
41079       {
41080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41081       };
41082     } catch (std::exception& e) {
41083       {
41084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41085       };
41086     } catch (Dali::DaliException e) {
41087       {
41088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41089       };
41090     } catch (...) {
41091       {
41092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41093       };
41094     }
41095   }
41096
41097 }
41098
41099
41100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
41101   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41102   Dali::Radian arg2 ;
41103   Dali::Radian arg3 ;
41104   Dali::Radian *argp2 ;
41105   Dali::Radian *argp3 ;
41106
41107   arg1 = (Dali::PanGestureDetector *)jarg1;
41108   argp2 = (Dali::Radian *)jarg2;
41109   if (!argp2) {
41110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41111     return ;
41112   }
41113   arg2 = *argp2;
41114   argp3 = (Dali::Radian *)jarg3;
41115   if (!argp3) {
41116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41117     return ;
41118   }
41119   arg3 = *argp3;
41120   {
41121     try {
41122       (arg1)->AddDirection(arg2,arg3);
41123     } catch (std::out_of_range& e) {
41124       {
41125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41126       };
41127     } catch (std::exception& e) {
41128       {
41129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41130       };
41131     } catch (Dali::DaliException e) {
41132       {
41133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41134       };
41135     } catch (...) {
41136       {
41137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41138       };
41139     }
41140   }
41141
41142 }
41143
41144
41145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
41146   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41147   Dali::Radian arg2 ;
41148   Dali::Radian *argp2 ;
41149
41150   arg1 = (Dali::PanGestureDetector *)jarg1;
41151   argp2 = (Dali::Radian *)jarg2;
41152   if (!argp2) {
41153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41154     return ;
41155   }
41156   arg2 = *argp2;
41157   {
41158     try {
41159       (arg1)->AddDirection(arg2);
41160     } catch (std::out_of_range& e) {
41161       {
41162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41163       };
41164     } catch (std::exception& e) {
41165       {
41166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41167       };
41168     } catch (Dali::DaliException e) {
41169       {
41170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41171       };
41172     } catch (...) {
41173       {
41174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41175       };
41176     }
41177   }
41178
41179 }
41180
41181
41182 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
41183   unsigned long jresult ;
41184   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41185   size_t result;
41186
41187   arg1 = (Dali::PanGestureDetector *)jarg1;
41188   {
41189     try {
41190       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
41191     } catch (std::out_of_range& e) {
41192       {
41193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41194       };
41195     } catch (std::exception& e) {
41196       {
41197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41198       };
41199     } catch (Dali::DaliException e) {
41200       {
41201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41202       };
41203     } catch (...) {
41204       {
41205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41206       };
41207     }
41208   }
41209
41210   jresult = (unsigned long)result;
41211   return jresult;
41212 }
41213
41214
41215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
41216   void * jresult ;
41217   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41218   size_t arg2 ;
41219   Dali::PanGestureDetector::AngleThresholdPair result;
41220
41221   arg1 = (Dali::PanGestureDetector *)jarg1;
41222   arg2 = (size_t)jarg2;
41223   {
41224     try {
41225       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
41226     } catch (std::out_of_range& e) {
41227       {
41228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41229       };
41230     } catch (std::exception& e) {
41231       {
41232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41233       };
41234     } catch (Dali::DaliException e) {
41235       {
41236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41237       };
41238     } catch (...) {
41239       {
41240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41241       };
41242     }
41243   }
41244
41245   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
41246   return jresult;
41247 }
41248
41249
41250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
41251   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41252
41253   arg1 = (Dali::PanGestureDetector *)jarg1;
41254   {
41255     try {
41256       (arg1)->ClearAngles();
41257     } catch (std::out_of_range& e) {
41258       {
41259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41260       };
41261     } catch (std::exception& e) {
41262       {
41263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41264       };
41265     } catch (Dali::DaliException e) {
41266       {
41267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41268       };
41269     } catch (...) {
41270       {
41271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41272       };
41273     }
41274   }
41275
41276 }
41277
41278
41279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
41280   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41281   Dali::Radian arg2 ;
41282   Dali::Radian *argp2 ;
41283
41284   arg1 = (Dali::PanGestureDetector *)jarg1;
41285   argp2 = (Dali::Radian *)jarg2;
41286   if (!argp2) {
41287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41288     return ;
41289   }
41290   arg2 = *argp2;
41291   {
41292     try {
41293       (arg1)->RemoveAngle(arg2);
41294     } catch (std::out_of_range& e) {
41295       {
41296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41297       };
41298     } catch (std::exception& e) {
41299       {
41300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41301       };
41302     } catch (Dali::DaliException e) {
41303       {
41304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41305       };
41306     } catch (...) {
41307       {
41308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41309       };
41310     }
41311   }
41312
41313 }
41314
41315
41316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
41317   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41318   Dali::Radian arg2 ;
41319   Dali::Radian *argp2 ;
41320
41321   arg1 = (Dali::PanGestureDetector *)jarg1;
41322   argp2 = (Dali::Radian *)jarg2;
41323   if (!argp2) {
41324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41325     return ;
41326   }
41327   arg2 = *argp2;
41328   {
41329     try {
41330       (arg1)->RemoveDirection(arg2);
41331     } catch (std::out_of_range& e) {
41332       {
41333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41334       };
41335     } catch (std::exception& e) {
41336       {
41337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41338       };
41339     } catch (Dali::DaliException e) {
41340       {
41341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41342       };
41343     } catch (...) {
41344       {
41345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41346       };
41347     }
41348   }
41349
41350 }
41351
41352
41353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
41354   void * jresult ;
41355   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41356   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
41357
41358   arg1 = (Dali::PanGestureDetector *)jarg1;
41359   {
41360     try {
41361       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41362     } catch (std::out_of_range& e) {
41363       {
41364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41365       };
41366     } catch (std::exception& e) {
41367       {
41368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41369       };
41370     } catch (Dali::DaliException e) {
41371       {
41372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41373       };
41374     } catch (...) {
41375       {
41376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41377       };
41378     }
41379   }
41380
41381   jresult = (void *)result;
41382   return jresult;
41383 }
41384
41385
41386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
41387   Dali::PanGesture *arg1 = 0 ;
41388
41389   arg1 = (Dali::PanGesture *)jarg1;
41390   if (!arg1) {
41391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41392     return ;
41393   }
41394   {
41395     try {
41396       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
41397     } catch (std::out_of_range& e) {
41398       {
41399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41400       };
41401     } catch (std::exception& e) {
41402       {
41403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41404       };
41405     } catch (Dali::DaliException e) {
41406       {
41407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41408       };
41409     } catch (...) {
41410       {
41411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41412       };
41413     }
41414   }
41415
41416 }
41417
41418
41419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41420   void * jresult ;
41421   Dali::PanGesture *result = 0 ;
41422
41423   {
41424     try {
41425       result = (Dali::PanGesture *)new Dali::PanGesture();
41426     } catch (std::out_of_range& e) {
41427       {
41428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41429       };
41430     } catch (std::exception& e) {
41431       {
41432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41433       };
41434     } catch (Dali::DaliException e) {
41435       {
41436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41437       };
41438     } catch (...) {
41439       {
41440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41441       };
41442     }
41443   }
41444
41445   jresult = (void *)result;
41446   return jresult;
41447 }
41448
41449
41450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41451   void * jresult ;
41452   Dali::Gesture::State arg1 ;
41453   Dali::PanGesture *result = 0 ;
41454
41455   arg1 = (Dali::Gesture::State)jarg1;
41456   {
41457     try {
41458       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41459     } catch (std::out_of_range& e) {
41460       {
41461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41462       };
41463     } catch (std::exception& e) {
41464       {
41465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41466       };
41467     } catch (Dali::DaliException e) {
41468       {
41469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41470       };
41471     } catch (...) {
41472       {
41473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41474       };
41475     }
41476   }
41477
41478   jresult = (void *)result;
41479   return jresult;
41480 }
41481
41482
41483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41484   void * jresult ;
41485   Dali::PanGesture *arg1 = 0 ;
41486   Dali::PanGesture *result = 0 ;
41487
41488   arg1 = (Dali::PanGesture *)jarg1;
41489   if (!arg1) {
41490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41491     return 0;
41492   }
41493   {
41494     try {
41495       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
41496     } catch (std::out_of_range& e) {
41497       {
41498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41499       };
41500     } catch (std::exception& e) {
41501       {
41502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41503       };
41504     } catch (Dali::DaliException e) {
41505       {
41506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41507       };
41508     } catch (...) {
41509       {
41510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41511       };
41512     }
41513   }
41514
41515   jresult = (void *)result;
41516   return jresult;
41517 }
41518
41519
41520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41521   void * jresult ;
41522   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41523   Dali::PanGesture *arg2 = 0 ;
41524   Dali::PanGesture *result = 0 ;
41525
41526   arg1 = (Dali::PanGesture *)jarg1;
41527   arg2 = (Dali::PanGesture *)jarg2;
41528   if (!arg2) {
41529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41530     return 0;
41531   }
41532   {
41533     try {
41534       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41535     } catch (std::out_of_range& e) {
41536       {
41537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41538       };
41539     } catch (std::exception& e) {
41540       {
41541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41542       };
41543     } catch (Dali::DaliException e) {
41544       {
41545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41546       };
41547     } catch (...) {
41548       {
41549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41550       };
41551     }
41552   }
41553
41554   jresult = (void *)result;
41555   return jresult;
41556 }
41557
41558
41559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41560   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41561
41562   arg1 = (Dali::PanGesture *)jarg1;
41563   {
41564     try {
41565       delete arg1;
41566     } catch (std::out_of_range& e) {
41567       {
41568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41569       };
41570     } catch (std::exception& e) {
41571       {
41572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41573       };
41574     } catch (Dali::DaliException e) {
41575       {
41576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41577       };
41578     } catch (...) {
41579       {
41580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41581       };
41582     }
41583   }
41584
41585 }
41586
41587
41588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41589   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41590   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41591
41592   arg1 = (Dali::PanGesture *)jarg1;
41593   arg2 = (Dali::Vector2 *)jarg2;
41594   if (arg1) (arg1)->velocity = *arg2;
41595 }
41596
41597
41598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41599   void * jresult ;
41600   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41601   Dali::Vector2 *result = 0 ;
41602
41603   arg1 = (Dali::PanGesture *)jarg1;
41604   result = (Dali::Vector2 *)& ((arg1)->velocity);
41605   jresult = (void *)result;
41606   return jresult;
41607 }
41608
41609
41610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41611   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41612   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41613
41614   arg1 = (Dali::PanGesture *)jarg1;
41615   arg2 = (Dali::Vector2 *)jarg2;
41616   if (arg1) (arg1)->displacement = *arg2;
41617 }
41618
41619
41620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41621   void * jresult ;
41622   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41623   Dali::Vector2 *result = 0 ;
41624
41625   arg1 = (Dali::PanGesture *)jarg1;
41626   result = (Dali::Vector2 *)& ((arg1)->displacement);
41627   jresult = (void *)result;
41628   return jresult;
41629 }
41630
41631
41632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41633   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41634   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41635
41636   arg1 = (Dali::PanGesture *)jarg1;
41637   arg2 = (Dali::Vector2 *)jarg2;
41638   if (arg1) (arg1)->position = *arg2;
41639 }
41640
41641
41642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41643   void * jresult ;
41644   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41645   Dali::Vector2 *result = 0 ;
41646
41647   arg1 = (Dali::PanGesture *)jarg1;
41648   result = (Dali::Vector2 *)& ((arg1)->position);
41649   jresult = (void *)result;
41650   return jresult;
41651 }
41652
41653
41654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41655   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41656   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41657
41658   arg1 = (Dali::PanGesture *)jarg1;
41659   arg2 = (Dali::Vector2 *)jarg2;
41660   if (arg1) (arg1)->screenVelocity = *arg2;
41661 }
41662
41663
41664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41665   void * jresult ;
41666   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41667   Dali::Vector2 *result = 0 ;
41668
41669   arg1 = (Dali::PanGesture *)jarg1;
41670   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41671   jresult = (void *)result;
41672   return jresult;
41673 }
41674
41675
41676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41677   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41678   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41679
41680   arg1 = (Dali::PanGesture *)jarg1;
41681   arg2 = (Dali::Vector2 *)jarg2;
41682   if (arg1) (arg1)->screenDisplacement = *arg2;
41683 }
41684
41685
41686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41687   void * jresult ;
41688   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41689   Dali::Vector2 *result = 0 ;
41690
41691   arg1 = (Dali::PanGesture *)jarg1;
41692   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41693   jresult = (void *)result;
41694   return jresult;
41695 }
41696
41697
41698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41699   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41700   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41701
41702   arg1 = (Dali::PanGesture *)jarg1;
41703   arg2 = (Dali::Vector2 *)jarg2;
41704   if (arg1) (arg1)->screenPosition = *arg2;
41705 }
41706
41707
41708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41709   void * jresult ;
41710   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41711   Dali::Vector2 *result = 0 ;
41712
41713   arg1 = (Dali::PanGesture *)jarg1;
41714   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41715   jresult = (void *)result;
41716   return jresult;
41717 }
41718
41719
41720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41721   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41722   unsigned int arg2 ;
41723
41724   arg1 = (Dali::PanGesture *)jarg1;
41725   arg2 = (unsigned int)jarg2;
41726   if (arg1) (arg1)->numberOfTouches = arg2;
41727 }
41728
41729
41730 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41731   unsigned int jresult ;
41732   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41733   unsigned int result;
41734
41735   arg1 = (Dali::PanGesture *)jarg1;
41736   result = (unsigned int) ((arg1)->numberOfTouches);
41737   jresult = result;
41738   return jresult;
41739 }
41740
41741
41742 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41743   float jresult ;
41744   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41745   float result;
41746
41747   arg1 = (Dali::PanGesture *)jarg1;
41748   {
41749     try {
41750       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41751     } catch (std::out_of_range& e) {
41752       {
41753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41754       };
41755     } catch (std::exception& e) {
41756       {
41757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41758       };
41759     } catch (Dali::DaliException e) {
41760       {
41761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41762       };
41763     } catch (...) {
41764       {
41765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41766       };
41767     }
41768   }
41769
41770   jresult = result;
41771   return jresult;
41772 }
41773
41774
41775 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41776   float jresult ;
41777   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41778   float result;
41779
41780   arg1 = (Dali::PanGesture *)jarg1;
41781   {
41782     try {
41783       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41784     } catch (std::out_of_range& e) {
41785       {
41786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41787       };
41788     } catch (std::exception& e) {
41789       {
41790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41791       };
41792     } catch (Dali::DaliException e) {
41793       {
41794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41795       };
41796     } catch (...) {
41797       {
41798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41799       };
41800     }
41801   }
41802
41803   jresult = result;
41804   return jresult;
41805 }
41806
41807
41808 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41809   float jresult ;
41810   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41811   float result;
41812
41813   arg1 = (Dali::PanGesture *)jarg1;
41814   {
41815     try {
41816       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41817     } catch (std::out_of_range& e) {
41818       {
41819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41820       };
41821     } catch (std::exception& e) {
41822       {
41823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41824       };
41825     } catch (Dali::DaliException e) {
41826       {
41827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41828       };
41829     } catch (...) {
41830       {
41831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41832       };
41833     }
41834   }
41835
41836   jresult = result;
41837   return jresult;
41838 }
41839
41840
41841 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41842   float jresult ;
41843   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41844   float result;
41845
41846   arg1 = (Dali::PanGesture *)jarg1;
41847   {
41848     try {
41849       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41850     } catch (std::out_of_range& e) {
41851       {
41852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41853       };
41854     } catch (std::exception& e) {
41855       {
41856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41857       };
41858     } catch (Dali::DaliException e) {
41859       {
41860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41861       };
41862     } catch (...) {
41863       {
41864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41865       };
41866     }
41867   }
41868
41869   jresult = result;
41870   return jresult;
41871 }
41872
41873
41874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41875   void * jresult ;
41876   Dali::PinchGestureDetector *result = 0 ;
41877
41878   {
41879     try {
41880       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41881     } catch (std::out_of_range& e) {
41882       {
41883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41884       };
41885     } catch (std::exception& e) {
41886       {
41887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41888       };
41889     } catch (Dali::DaliException e) {
41890       {
41891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41892       };
41893     } catch (...) {
41894       {
41895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41896       };
41897     }
41898   }
41899
41900   jresult = (void *)result;
41901   return jresult;
41902 }
41903
41904
41905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41906   void * jresult ;
41907   Dali::PinchGestureDetector result;
41908
41909   {
41910     try {
41911       result = Dali::PinchGestureDetector::New();
41912     } catch (std::out_of_range& e) {
41913       {
41914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41915       };
41916     } catch (std::exception& e) {
41917       {
41918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41919       };
41920     } catch (Dali::DaliException e) {
41921       {
41922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41923       };
41924     } catch (...) {
41925       {
41926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41927       };
41928     }
41929   }
41930
41931   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41932   return jresult;
41933 }
41934
41935
41936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41937   void * jresult ;
41938   Dali::BaseHandle arg1 ;
41939   Dali::BaseHandle *argp1 ;
41940   Dali::PinchGestureDetector result;
41941
41942   argp1 = (Dali::BaseHandle *)jarg1;
41943   if (!argp1) {
41944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41945     return 0;
41946   }
41947   arg1 = *argp1;
41948   {
41949     try {
41950       result = Dali::PinchGestureDetector::DownCast(arg1);
41951     } catch (std::out_of_range& e) {
41952       {
41953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41954       };
41955     } catch (std::exception& e) {
41956       {
41957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41958       };
41959     } catch (Dali::DaliException e) {
41960       {
41961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41962       };
41963     } catch (...) {
41964       {
41965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41966       };
41967     }
41968   }
41969
41970   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41971   return jresult;
41972 }
41973
41974
41975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41976   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41977
41978   arg1 = (Dali::PinchGestureDetector *)jarg1;
41979   {
41980     try {
41981       delete arg1;
41982     } catch (std::out_of_range& e) {
41983       {
41984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41985       };
41986     } catch (std::exception& e) {
41987       {
41988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41989       };
41990     } catch (Dali::DaliException e) {
41991       {
41992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41993       };
41994     } catch (...) {
41995       {
41996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41997       };
41998     }
41999   }
42000
42001 }
42002
42003
42004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
42005   void * jresult ;
42006   Dali::PinchGestureDetector *arg1 = 0 ;
42007   Dali::PinchGestureDetector *result = 0 ;
42008
42009   arg1 = (Dali::PinchGestureDetector *)jarg1;
42010   if (!arg1) {
42011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
42012     return 0;
42013   }
42014   {
42015     try {
42016       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
42017     } catch (std::out_of_range& e) {
42018       {
42019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42020       };
42021     } catch (std::exception& e) {
42022       {
42023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42024       };
42025     } catch (Dali::DaliException e) {
42026       {
42027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42028       };
42029     } catch (...) {
42030       {
42031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42032       };
42033     }
42034   }
42035
42036   jresult = (void *)result;
42037   return jresult;
42038 }
42039
42040
42041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
42042   void * jresult ;
42043   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
42044   Dali::PinchGestureDetector *arg2 = 0 ;
42045   Dali::PinchGestureDetector *result = 0 ;
42046
42047   arg1 = (Dali::PinchGestureDetector *)jarg1;
42048   arg2 = (Dali::PinchGestureDetector *)jarg2;
42049   if (!arg2) {
42050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
42051     return 0;
42052   }
42053   {
42054     try {
42055       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
42056     } catch (std::out_of_range& e) {
42057       {
42058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42059       };
42060     } catch (std::exception& e) {
42061       {
42062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42063       };
42064     } catch (Dali::DaliException e) {
42065       {
42066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42067       };
42068     } catch (...) {
42069       {
42070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42071       };
42072     }
42073   }
42074
42075   jresult = (void *)result;
42076   return jresult;
42077 }
42078
42079
42080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
42081   void * jresult ;
42082   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
42083   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
42084
42085   arg1 = (Dali::PinchGestureDetector *)jarg1;
42086   {
42087     try {
42088       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42089     } catch (std::out_of_range& e) {
42090       {
42091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42092       };
42093     } catch (std::exception& e) {
42094       {
42095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42096       };
42097     } catch (Dali::DaliException e) {
42098       {
42099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42100       };
42101     } catch (...) {
42102       {
42103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42104       };
42105     }
42106   }
42107
42108   jresult = (void *)result;
42109   return jresult;
42110 }
42111
42112
42113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
42114   void * jresult ;
42115   Dali::Gesture::State arg1 ;
42116   Dali::PinchGesture *result = 0 ;
42117
42118   arg1 = (Dali::Gesture::State)jarg1;
42119   {
42120     try {
42121       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
42122     } catch (std::out_of_range& e) {
42123       {
42124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42125       };
42126     } catch (std::exception& e) {
42127       {
42128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42129       };
42130     } catch (Dali::DaliException e) {
42131       {
42132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42133       };
42134     } catch (...) {
42135       {
42136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42137       };
42138     }
42139   }
42140
42141   jresult = (void *)result;
42142   return jresult;
42143 }
42144
42145
42146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
42147   void * jresult ;
42148   Dali::PinchGesture *arg1 = 0 ;
42149   Dali::PinchGesture *result = 0 ;
42150
42151   arg1 = (Dali::PinchGesture *)jarg1;
42152   if (!arg1) {
42153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42154     return 0;
42155   }
42156   {
42157     try {
42158       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
42159     } catch (std::out_of_range& e) {
42160       {
42161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42162       };
42163     } catch (std::exception& e) {
42164       {
42165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42166       };
42167     } catch (Dali::DaliException e) {
42168       {
42169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42170       };
42171     } catch (...) {
42172       {
42173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42174       };
42175     }
42176   }
42177
42178   jresult = (void *)result;
42179   return jresult;
42180 }
42181
42182
42183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
42184   void * jresult ;
42185   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42186   Dali::PinchGesture *arg2 = 0 ;
42187   Dali::PinchGesture *result = 0 ;
42188
42189   arg1 = (Dali::PinchGesture *)jarg1;
42190   arg2 = (Dali::PinchGesture *)jarg2;
42191   if (!arg2) {
42192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42193     return 0;
42194   }
42195   {
42196     try {
42197       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
42198     } catch (std::out_of_range& e) {
42199       {
42200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42201       };
42202     } catch (std::exception& e) {
42203       {
42204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42205       };
42206     } catch (Dali::DaliException e) {
42207       {
42208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42209       };
42210     } catch (...) {
42211       {
42212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42213       };
42214     }
42215   }
42216
42217   jresult = (void *)result;
42218   return jresult;
42219 }
42220
42221
42222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
42223   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42224
42225   arg1 = (Dali::PinchGesture *)jarg1;
42226   {
42227     try {
42228       delete arg1;
42229     } catch (std::out_of_range& e) {
42230       {
42231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42232       };
42233     } catch (std::exception& e) {
42234       {
42235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42236       };
42237     } catch (Dali::DaliException e) {
42238       {
42239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42240       };
42241     } catch (...) {
42242       {
42243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42244       };
42245     }
42246   }
42247
42248 }
42249
42250
42251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
42252   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42253   float arg2 ;
42254
42255   arg1 = (Dali::PinchGesture *)jarg1;
42256   arg2 = (float)jarg2;
42257   if (arg1) (arg1)->scale = arg2;
42258 }
42259
42260
42261 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
42262   float jresult ;
42263   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42264   float result;
42265
42266   arg1 = (Dali::PinchGesture *)jarg1;
42267   result = (float) ((arg1)->scale);
42268   jresult = result;
42269   return jresult;
42270 }
42271
42272
42273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
42274   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42275   float arg2 ;
42276
42277   arg1 = (Dali::PinchGesture *)jarg1;
42278   arg2 = (float)jarg2;
42279   if (arg1) (arg1)->speed = arg2;
42280 }
42281
42282
42283 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
42284   float jresult ;
42285   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42286   float result;
42287
42288   arg1 = (Dali::PinchGesture *)jarg1;
42289   result = (float) ((arg1)->speed);
42290   jresult = result;
42291   return jresult;
42292 }
42293
42294
42295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
42296   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42297   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42298
42299   arg1 = (Dali::PinchGesture *)jarg1;
42300   arg2 = (Dali::Vector2 *)jarg2;
42301   if (arg1) (arg1)->screenCenterPoint = *arg2;
42302 }
42303
42304
42305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
42306   void * jresult ;
42307   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42308   Dali::Vector2 *result = 0 ;
42309
42310   arg1 = (Dali::PinchGesture *)jarg1;
42311   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
42312   jresult = (void *)result;
42313   return jresult;
42314 }
42315
42316
42317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
42318   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42319   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42320
42321   arg1 = (Dali::PinchGesture *)jarg1;
42322   arg2 = (Dali::Vector2 *)jarg2;
42323   if (arg1) (arg1)->localCenterPoint = *arg2;
42324 }
42325
42326
42327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
42328   void * jresult ;
42329   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42330   Dali::Vector2 *result = 0 ;
42331
42332   arg1 = (Dali::PinchGesture *)jarg1;
42333   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
42334   jresult = (void *)result;
42335   return jresult;
42336 }
42337
42338
42339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
42340   void * jresult ;
42341   Dali::TapGestureDetector *result = 0 ;
42342
42343   {
42344     try {
42345       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
42346     } catch (std::out_of_range& e) {
42347       {
42348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42349       };
42350     } catch (std::exception& e) {
42351       {
42352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42353       };
42354     } catch (Dali::DaliException e) {
42355       {
42356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42357       };
42358     } catch (...) {
42359       {
42360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42361       };
42362     }
42363   }
42364
42365   jresult = (void *)result;
42366   return jresult;
42367 }
42368
42369
42370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
42371   void * jresult ;
42372   Dali::TapGestureDetector result;
42373
42374   {
42375     try {
42376       result = Dali::TapGestureDetector::New();
42377     } catch (std::out_of_range& e) {
42378       {
42379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42380       };
42381     } catch (std::exception& e) {
42382       {
42383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42384       };
42385     } catch (Dali::DaliException e) {
42386       {
42387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42388       };
42389     } catch (...) {
42390       {
42391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42392       };
42393     }
42394   }
42395
42396   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42397   return jresult;
42398 }
42399
42400
42401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
42402   void * jresult ;
42403   unsigned int arg1 ;
42404   Dali::TapGestureDetector result;
42405
42406   arg1 = (unsigned int)jarg1;
42407   {
42408     try {
42409       result = Dali::TapGestureDetector::New(arg1);
42410     } catch (std::out_of_range& e) {
42411       {
42412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42413       };
42414     } catch (std::exception& e) {
42415       {
42416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42417       };
42418     } catch (Dali::DaliException e) {
42419       {
42420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42421       };
42422     } catch (...) {
42423       {
42424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42425       };
42426     }
42427   }
42428
42429   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42430   return jresult;
42431 }
42432
42433
42434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42435   void * jresult ;
42436   Dali::BaseHandle arg1 ;
42437   Dali::BaseHandle *argp1 ;
42438   Dali::TapGestureDetector result;
42439
42440   argp1 = (Dali::BaseHandle *)jarg1;
42441   if (!argp1) {
42442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42443     return 0;
42444   }
42445   arg1 = *argp1;
42446   {
42447     try {
42448       result = Dali::TapGestureDetector::DownCast(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 = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42469   return jresult;
42470 }
42471
42472
42473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42474   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42475
42476   arg1 = (Dali::TapGestureDetector *)jarg1;
42477   {
42478     try {
42479       delete arg1;
42480     } catch (std::out_of_range& e) {
42481       {
42482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42483       };
42484     } catch (std::exception& e) {
42485       {
42486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42487       };
42488     } catch (Dali::DaliException e) {
42489       {
42490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42491       };
42492     } catch (...) {
42493       {
42494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42495       };
42496     }
42497   }
42498
42499 }
42500
42501
42502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42503   void * jresult ;
42504   Dali::TapGestureDetector *arg1 = 0 ;
42505   Dali::TapGestureDetector *result = 0 ;
42506
42507   arg1 = (Dali::TapGestureDetector *)jarg1;
42508   if (!arg1) {
42509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42510     return 0;
42511   }
42512   {
42513     try {
42514       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42515     } catch (std::out_of_range& e) {
42516       {
42517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42518       };
42519     } catch (std::exception& e) {
42520       {
42521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42522       };
42523     } catch (Dali::DaliException e) {
42524       {
42525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42526       };
42527     } catch (...) {
42528       {
42529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42530       };
42531     }
42532   }
42533
42534   jresult = (void *)result;
42535   return jresult;
42536 }
42537
42538
42539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42540   void * jresult ;
42541   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42542   Dali::TapGestureDetector *arg2 = 0 ;
42543   Dali::TapGestureDetector *result = 0 ;
42544
42545   arg1 = (Dali::TapGestureDetector *)jarg1;
42546   arg2 = (Dali::TapGestureDetector *)jarg2;
42547   if (!arg2) {
42548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42549     return 0;
42550   }
42551   {
42552     try {
42553       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42554     } catch (std::out_of_range& e) {
42555       {
42556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42557       };
42558     } catch (std::exception& e) {
42559       {
42560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42561       };
42562     } catch (Dali::DaliException e) {
42563       {
42564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42565       };
42566     } catch (...) {
42567       {
42568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42569       };
42570     }
42571   }
42572
42573   jresult = (void *)result;
42574   return jresult;
42575 }
42576
42577
42578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42579   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42580   unsigned int arg2 ;
42581
42582   arg1 = (Dali::TapGestureDetector *)jarg1;
42583   arg2 = (unsigned int)jarg2;
42584   {
42585     try {
42586       (arg1)->SetMinimumTapsRequired(arg2);
42587     } catch (std::out_of_range& e) {
42588       {
42589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42590       };
42591     } catch (std::exception& e) {
42592       {
42593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42594       };
42595     } catch (Dali::DaliException e) {
42596       {
42597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42598       };
42599     } catch (...) {
42600       {
42601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42602       };
42603     }
42604   }
42605
42606 }
42607
42608
42609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42610   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42611   unsigned int arg2 ;
42612
42613   arg1 = (Dali::TapGestureDetector *)jarg1;
42614   arg2 = (unsigned int)jarg2;
42615   {
42616     try {
42617       (arg1)->SetMaximumTapsRequired(arg2);
42618     } catch (std::out_of_range& e) {
42619       {
42620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42621       };
42622     } catch (std::exception& e) {
42623       {
42624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42625       };
42626     } catch (Dali::DaliException e) {
42627       {
42628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42629       };
42630     } catch (...) {
42631       {
42632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42633       };
42634     }
42635   }
42636
42637 }
42638
42639
42640 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42641   unsigned int jresult ;
42642   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42643   unsigned int result;
42644
42645   arg1 = (Dali::TapGestureDetector *)jarg1;
42646   {
42647     try {
42648       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42649     } catch (std::out_of_range& e) {
42650       {
42651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42652       };
42653     } catch (std::exception& e) {
42654       {
42655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42656       };
42657     } catch (Dali::DaliException e) {
42658       {
42659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42660       };
42661     } catch (...) {
42662       {
42663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42664       };
42665     }
42666   }
42667
42668   jresult = result;
42669   return jresult;
42670 }
42671
42672
42673 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42674   unsigned int jresult ;
42675   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42676   unsigned int result;
42677
42678   arg1 = (Dali::TapGestureDetector *)jarg1;
42679   {
42680     try {
42681       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42682     } catch (std::out_of_range& e) {
42683       {
42684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42685       };
42686     } catch (std::exception& e) {
42687       {
42688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42689       };
42690     } catch (Dali::DaliException e) {
42691       {
42692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42693       };
42694     } catch (...) {
42695       {
42696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42697       };
42698     }
42699   }
42700
42701   jresult = result;
42702   return jresult;
42703 }
42704
42705
42706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42707   void * jresult ;
42708   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42709   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42710
42711   arg1 = (Dali::TapGestureDetector *)jarg1;
42712   {
42713     try {
42714       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42715     } catch (std::out_of_range& e) {
42716       {
42717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42718       };
42719     } catch (std::exception& e) {
42720       {
42721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42722       };
42723     } catch (Dali::DaliException e) {
42724       {
42725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42726       };
42727     } catch (...) {
42728       {
42729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42730       };
42731     }
42732   }
42733
42734   jresult = (void *)result;
42735   return jresult;
42736 }
42737
42738
42739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42740   void * jresult ;
42741   Dali::TapGesture *result = 0 ;
42742
42743   {
42744     try {
42745       result = (Dali::TapGesture *)new Dali::TapGesture();
42746     } catch (std::out_of_range& e) {
42747       {
42748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42749       };
42750     } catch (std::exception& e) {
42751       {
42752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42753       };
42754     } catch (Dali::DaliException e) {
42755       {
42756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42757       };
42758     } catch (...) {
42759       {
42760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42761       };
42762     }
42763   }
42764
42765   jresult = (void *)result;
42766   return jresult;
42767 }
42768
42769
42770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42771   void * jresult ;
42772   Dali::TapGesture *arg1 = 0 ;
42773   Dali::TapGesture *result = 0 ;
42774
42775   arg1 = (Dali::TapGesture *)jarg1;
42776   if (!arg1) {
42777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42778     return 0;
42779   }
42780   {
42781     try {
42782       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42783     } catch (std::out_of_range& e) {
42784       {
42785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42786       };
42787     } catch (std::exception& e) {
42788       {
42789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42790       };
42791     } catch (Dali::DaliException e) {
42792       {
42793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42794       };
42795     } catch (...) {
42796       {
42797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42798       };
42799     }
42800   }
42801
42802   jresult = (void *)result;
42803   return jresult;
42804 }
42805
42806
42807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42808   void * jresult ;
42809   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42810   Dali::TapGesture *arg2 = 0 ;
42811   Dali::TapGesture *result = 0 ;
42812
42813   arg1 = (Dali::TapGesture *)jarg1;
42814   arg2 = (Dali::TapGesture *)jarg2;
42815   if (!arg2) {
42816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42817     return 0;
42818   }
42819   {
42820     try {
42821       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42822     } catch (std::out_of_range& e) {
42823       {
42824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42825       };
42826     } catch (std::exception& e) {
42827       {
42828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42829       };
42830     } catch (Dali::DaliException e) {
42831       {
42832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42833       };
42834     } catch (...) {
42835       {
42836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42837       };
42838     }
42839   }
42840
42841   jresult = (void *)result;
42842   return jresult;
42843 }
42844
42845
42846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42847   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42848
42849   arg1 = (Dali::TapGesture *)jarg1;
42850   {
42851     try {
42852       delete arg1;
42853     } catch (std::out_of_range& e) {
42854       {
42855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42856       };
42857     } catch (std::exception& e) {
42858       {
42859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42860       };
42861     } catch (Dali::DaliException e) {
42862       {
42863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42864       };
42865     } catch (...) {
42866       {
42867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42868       };
42869     }
42870   }
42871
42872 }
42873
42874
42875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42876   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42877   unsigned int arg2 ;
42878
42879   arg1 = (Dali::TapGesture *)jarg1;
42880   arg2 = (unsigned int)jarg2;
42881   if (arg1) (arg1)->numberOfTaps = arg2;
42882 }
42883
42884
42885 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42886   unsigned int jresult ;
42887   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42888   unsigned int result;
42889
42890   arg1 = (Dali::TapGesture *)jarg1;
42891   result = (unsigned int) ((arg1)->numberOfTaps);
42892   jresult = result;
42893   return jresult;
42894 }
42895
42896
42897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42898   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42899   unsigned int arg2 ;
42900
42901   arg1 = (Dali::TapGesture *)jarg1;
42902   arg2 = (unsigned int)jarg2;
42903   if (arg1) (arg1)->numberOfTouches = arg2;
42904 }
42905
42906
42907 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42908   unsigned int jresult ;
42909   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42910   unsigned int result;
42911
42912   arg1 = (Dali::TapGesture *)jarg1;
42913   result = (unsigned int) ((arg1)->numberOfTouches);
42914   jresult = result;
42915   return jresult;
42916 }
42917
42918
42919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42920   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42921   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42922
42923   arg1 = (Dali::TapGesture *)jarg1;
42924   arg2 = (Dali::Vector2 *)jarg2;
42925   if (arg1) (arg1)->screenPoint = *arg2;
42926 }
42927
42928
42929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42930   void * jresult ;
42931   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42932   Dali::Vector2 *result = 0 ;
42933
42934   arg1 = (Dali::TapGesture *)jarg1;
42935   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42936   jresult = (void *)result;
42937   return jresult;
42938 }
42939
42940
42941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42942   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42943   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42944
42945   arg1 = (Dali::TapGesture *)jarg1;
42946   arg2 = (Dali::Vector2 *)jarg2;
42947   if (arg1) (arg1)->localPoint = *arg2;
42948 }
42949
42950
42951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42952   void * jresult ;
42953   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42954   Dali::Vector2 *result = 0 ;
42955
42956   arg1 = (Dali::TapGesture *)jarg1;
42957   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42958   jresult = (void *)result;
42959   return jresult;
42960 }
42961
42962
42963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42964   void * jresult ;
42965   Dali::AlphaFunction *result = 0 ;
42966
42967   {
42968     try {
42969       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42970     } catch (std::out_of_range& e) {
42971       {
42972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42973       };
42974     } catch (std::exception& e) {
42975       {
42976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42977       };
42978     } catch (Dali::DaliException e) {
42979       {
42980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42981       };
42982     } catch (...) {
42983       {
42984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42985       };
42986     }
42987   }
42988
42989   jresult = (void *)result;
42990   return jresult;
42991 }
42992
42993
42994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42995   void * jresult ;
42996   Dali::AlphaFunction::BuiltinFunction arg1 ;
42997   Dali::AlphaFunction *result = 0 ;
42998
42999   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
43000   {
43001     try {
43002       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
43003     } catch (std::out_of_range& e) {
43004       {
43005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43006       };
43007     } catch (std::exception& e) {
43008       {
43009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43010       };
43011     } catch (Dali::DaliException e) {
43012       {
43013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43014       };
43015     } catch (...) {
43016       {
43017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43018       };
43019     }
43020   }
43021
43022   jresult = (void *)result;
43023   return jresult;
43024 }
43025
43026
43027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
43028   void * jresult ;
43029   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
43030   Dali::AlphaFunction *result = 0 ;
43031
43032   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
43033   {
43034     try {
43035       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
43036     } catch (std::out_of_range& e) {
43037       {
43038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43039       };
43040     } catch (std::exception& e) {
43041       {
43042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43043       };
43044     } catch (Dali::DaliException e) {
43045       {
43046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43047       };
43048     } catch (...) {
43049       {
43050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43051       };
43052     }
43053   }
43054
43055   jresult = (void *)result;
43056   return jresult;
43057 }
43058
43059
43060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
43061   void * jresult ;
43062   Dali::Vector2 *arg1 = 0 ;
43063   Dali::Vector2 *arg2 = 0 ;
43064   Dali::AlphaFunction *result = 0 ;
43065
43066   arg1 = (Dali::Vector2 *)jarg1;
43067   if (!arg1) {
43068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43069     return 0;
43070   }
43071   arg2 = (Dali::Vector2 *)jarg2;
43072   if (!arg2) {
43073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43074     return 0;
43075   }
43076   {
43077     try {
43078       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
43079     } catch (std::out_of_range& e) {
43080       {
43081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43082       };
43083     } catch (std::exception& e) {
43084       {
43085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43086       };
43087     } catch (Dali::DaliException e) {
43088       {
43089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43090       };
43091     } catch (...) {
43092       {
43093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43094       };
43095     }
43096   }
43097
43098   jresult = (void *)result;
43099   return jresult;
43100 }
43101
43102
43103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
43104   void * jresult ;
43105   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43106   Dali::Vector4 result;
43107
43108   arg1 = (Dali::AlphaFunction *)jarg1;
43109   {
43110     try {
43111       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
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 = new Dali::Vector4((const Dali::Vector4 &)result);
43132   return jresult;
43133 }
43134
43135
43136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
43137   void * jresult ;
43138   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43139   Dali::AlphaFunctionPrototype result;
43140
43141   arg1 = (Dali::AlphaFunction *)jarg1;
43142   {
43143     try {
43144       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
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 = (void *)result;
43165   return jresult;
43166 }
43167
43168
43169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
43170   int jresult ;
43171   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43172   Dali::AlphaFunction::BuiltinFunction result;
43173
43174   arg1 = (Dali::AlphaFunction *)jarg1;
43175   {
43176     try {
43177       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
43178     } catch (std::out_of_range& e) {
43179       {
43180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43181       };
43182     } catch (std::exception& e) {
43183       {
43184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43185       };
43186     } catch (Dali::DaliException e) {
43187       {
43188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43189       };
43190     } catch (...) {
43191       {
43192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43193       };
43194     }
43195   }
43196
43197   jresult = (int)result;
43198   return jresult;
43199 }
43200
43201
43202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
43203   int jresult ;
43204   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43205   Dali::AlphaFunction::Mode result;
43206
43207   arg1 = (Dali::AlphaFunction *)jarg1;
43208   {
43209     try {
43210       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
43211     } catch (std::out_of_range& e) {
43212       {
43213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43214       };
43215     } catch (std::exception& e) {
43216       {
43217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43218       };
43219     } catch (Dali::DaliException e) {
43220       {
43221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43222       };
43223     } catch (...) {
43224       {
43225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43226       };
43227     }
43228   }
43229
43230   jresult = (int)result;
43231   return jresult;
43232 }
43233
43234
43235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
43236   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43237
43238   arg1 = (Dali::AlphaFunction *)jarg1;
43239   {
43240     try {
43241       delete arg1;
43242     } catch (std::out_of_range& e) {
43243       {
43244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43245       };
43246     } catch (std::exception& e) {
43247       {
43248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43249       };
43250     } catch (Dali::DaliException e) {
43251       {
43252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43253       };
43254     } catch (...) {
43255       {
43256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43257       };
43258     }
43259   }
43260
43261 }
43262
43263
43264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
43265   void * jresult ;
43266   Dali::KeyFrames result;
43267
43268   {
43269     try {
43270       result = Dali::KeyFrames::New();
43271     } catch (std::out_of_range& e) {
43272       {
43273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43274       };
43275     } catch (std::exception& e) {
43276       {
43277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43278       };
43279     } catch (Dali::DaliException e) {
43280       {
43281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43282       };
43283     } catch (...) {
43284       {
43285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43286       };
43287     }
43288   }
43289
43290   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43291   return jresult;
43292 }
43293
43294
43295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
43296   void * jresult ;
43297   Dali::BaseHandle arg1 ;
43298   Dali::BaseHandle *argp1 ;
43299   Dali::KeyFrames result;
43300
43301   argp1 = (Dali::BaseHandle *)jarg1;
43302   if (!argp1) {
43303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43304     return 0;
43305   }
43306   arg1 = *argp1;
43307   {
43308     try {
43309       result = Dali::KeyFrames::DownCast(arg1);
43310     } catch (std::out_of_range& e) {
43311       {
43312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43313       };
43314     } catch (std::exception& e) {
43315       {
43316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43317       };
43318     } catch (Dali::DaliException e) {
43319       {
43320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43321       };
43322     } catch (...) {
43323       {
43324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43325       };
43326     }
43327   }
43328
43329   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43330   return jresult;
43331 }
43332
43333
43334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
43335   void * jresult ;
43336   Dali::KeyFrames *result = 0 ;
43337
43338   {
43339     try {
43340       result = (Dali::KeyFrames *)new Dali::KeyFrames();
43341     } catch (std::out_of_range& e) {
43342       {
43343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43344       };
43345     } catch (std::exception& e) {
43346       {
43347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43348       };
43349     } catch (Dali::DaliException e) {
43350       {
43351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43352       };
43353     } catch (...) {
43354       {
43355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43356       };
43357     }
43358   }
43359
43360   jresult = (void *)result;
43361   return jresult;
43362 }
43363
43364
43365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
43366   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43367
43368   arg1 = (Dali::KeyFrames *)jarg1;
43369   {
43370     try {
43371       delete arg1;
43372     } catch (std::out_of_range& e) {
43373       {
43374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43375       };
43376     } catch (std::exception& e) {
43377       {
43378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43379       };
43380     } catch (Dali::DaliException e) {
43381       {
43382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43383       };
43384     } catch (...) {
43385       {
43386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43387       };
43388     }
43389   }
43390
43391 }
43392
43393
43394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
43395   void * jresult ;
43396   Dali::KeyFrames *arg1 = 0 ;
43397   Dali::KeyFrames *result = 0 ;
43398
43399   arg1 = (Dali::KeyFrames *)jarg1;
43400   if (!arg1) {
43401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43402     return 0;
43403   }
43404   {
43405     try {
43406       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
43407     } catch (std::out_of_range& e) {
43408       {
43409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43410       };
43411     } catch (std::exception& e) {
43412       {
43413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43414       };
43415     } catch (Dali::DaliException e) {
43416       {
43417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43418       };
43419     } catch (...) {
43420       {
43421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43422       };
43423     }
43424   }
43425
43426   jresult = (void *)result;
43427   return jresult;
43428 }
43429
43430
43431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43432   void * jresult ;
43433   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43434   Dali::KeyFrames *arg2 = 0 ;
43435   Dali::KeyFrames *result = 0 ;
43436
43437   arg1 = (Dali::KeyFrames *)jarg1;
43438   arg2 = (Dali::KeyFrames *)jarg2;
43439   if (!arg2) {
43440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43441     return 0;
43442   }
43443   {
43444     try {
43445       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43446     } catch (std::out_of_range& e) {
43447       {
43448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43449       };
43450     } catch (std::exception& e) {
43451       {
43452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43453       };
43454     } catch (Dali::DaliException e) {
43455       {
43456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43457       };
43458     } catch (...) {
43459       {
43460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43461       };
43462     }
43463   }
43464
43465   jresult = (void *)result;
43466   return jresult;
43467 }
43468
43469
43470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43471   int jresult ;
43472   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43473   Dali::Property::Type result;
43474
43475   arg1 = (Dali::KeyFrames *)jarg1;
43476   {
43477     try {
43478       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43479     } catch (std::out_of_range& e) {
43480       {
43481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43482       };
43483     } catch (std::exception& e) {
43484       {
43485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43486       };
43487     } catch (Dali::DaliException e) {
43488       {
43489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43490       };
43491     } catch (...) {
43492       {
43493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43494       };
43495     }
43496   }
43497
43498   jresult = (int)result;
43499   return jresult;
43500 }
43501
43502
43503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43504   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43505   float arg2 ;
43506   Dali::Property::Value arg3 ;
43507   Dali::Property::Value *argp3 ;
43508
43509   arg1 = (Dali::KeyFrames *)jarg1;
43510   arg2 = (float)jarg2;
43511   argp3 = (Dali::Property::Value *)jarg3;
43512   if (!argp3) {
43513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43514     return ;
43515   }
43516   arg3 = *argp3;
43517   {
43518     try {
43519       (arg1)->Add(arg2,arg3);
43520     } catch (std::out_of_range& e) {
43521       {
43522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43523       };
43524     } catch (std::exception& e) {
43525       {
43526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43527       };
43528     } catch (Dali::DaliException e) {
43529       {
43530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43531       };
43532     } catch (...) {
43533       {
43534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43535       };
43536     }
43537   }
43538
43539 }
43540
43541
43542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43543   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43544   float arg2 ;
43545   Dali::Property::Value arg3 ;
43546   Dali::AlphaFunction arg4 ;
43547   Dali::Property::Value *argp3 ;
43548   Dali::AlphaFunction *argp4 ;
43549
43550   arg1 = (Dali::KeyFrames *)jarg1;
43551   arg2 = (float)jarg2;
43552   argp3 = (Dali::Property::Value *)jarg3;
43553   if (!argp3) {
43554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43555     return ;
43556   }
43557   arg3 = *argp3;
43558   argp4 = (Dali::AlphaFunction *)jarg4;
43559   if (!argp4) {
43560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43561     return ;
43562   }
43563   arg4 = *argp4;
43564   {
43565     try {
43566       (arg1)->Add(arg2,arg3,arg4);
43567     } catch (std::out_of_range& e) {
43568       {
43569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43570       };
43571     } catch (std::exception& e) {
43572       {
43573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43574       };
43575     } catch (Dali::DaliException e) {
43576       {
43577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43578       };
43579     } catch (...) {
43580       {
43581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43582       };
43583     }
43584   }
43585
43586 }
43587
43588
43589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43590   int jresult ;
43591   int result;
43592
43593   result = (int)Dali::Path::Property::POINTS;
43594   jresult = (int)result;
43595   return jresult;
43596 }
43597
43598
43599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43600   int jresult ;
43601   int result;
43602
43603   result = (int)Dali::Path::Property::CONTROL_POINTS;
43604   jresult = (int)result;
43605   return jresult;
43606 }
43607
43608
43609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43610   void * jresult ;
43611   Dali::Path::Property *result = 0 ;
43612
43613   {
43614     try {
43615       result = (Dali::Path::Property *)new Dali::Path::Property();
43616     } catch (std::out_of_range& e) {
43617       {
43618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43619       };
43620     } catch (std::exception& e) {
43621       {
43622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43623       };
43624     } catch (Dali::DaliException e) {
43625       {
43626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43627       };
43628     } catch (...) {
43629       {
43630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43631       };
43632     }
43633   }
43634
43635   jresult = (void *)result;
43636   return jresult;
43637 }
43638
43639
43640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43641   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43642
43643   arg1 = (Dali::Path::Property *)jarg1;
43644   {
43645     try {
43646       delete arg1;
43647     } catch (std::out_of_range& e) {
43648       {
43649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43650       };
43651     } catch (std::exception& e) {
43652       {
43653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43654       };
43655     } catch (Dali::DaliException e) {
43656       {
43657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43658       };
43659     } catch (...) {
43660       {
43661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43662       };
43663     }
43664   }
43665
43666 }
43667
43668
43669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43670   void * jresult ;
43671   Dali::Path result;
43672
43673   {
43674     try {
43675       result = Dali::Path::New();
43676     } catch (std::out_of_range& e) {
43677       {
43678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43679       };
43680     } catch (std::exception& e) {
43681       {
43682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43683       };
43684     } catch (Dali::DaliException e) {
43685       {
43686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43687       };
43688     } catch (...) {
43689       {
43690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43691       };
43692     }
43693   }
43694
43695   jresult = new Dali::Path((const Dali::Path &)result);
43696   return jresult;
43697 }
43698
43699
43700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43701   void * jresult ;
43702   Dali::BaseHandle arg1 ;
43703   Dali::BaseHandle *argp1 ;
43704   Dali::Path result;
43705
43706   argp1 = (Dali::BaseHandle *)jarg1;
43707   if (!argp1) {
43708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43709     return 0;
43710   }
43711   arg1 = *argp1;
43712   {
43713     try {
43714       result = Dali::Path::DownCast(arg1);
43715     } catch (std::out_of_range& e) {
43716       {
43717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43718       };
43719     } catch (std::exception& e) {
43720       {
43721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43722       };
43723     } catch (Dali::DaliException e) {
43724       {
43725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43726       };
43727     } catch (...) {
43728       {
43729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43730       };
43731     }
43732   }
43733
43734   jresult = new Dali::Path((const Dali::Path &)result);
43735   return jresult;
43736 }
43737
43738
43739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43740   void * jresult ;
43741   Dali::Path *result = 0 ;
43742
43743   {
43744     try {
43745       result = (Dali::Path *)new Dali::Path();
43746     } catch (std::out_of_range& e) {
43747       {
43748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43749       };
43750     } catch (std::exception& e) {
43751       {
43752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43753       };
43754     } catch (Dali::DaliException e) {
43755       {
43756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43757       };
43758     } catch (...) {
43759       {
43760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43761       };
43762     }
43763   }
43764
43765   jresult = (void *)result;
43766   return jresult;
43767 }
43768
43769
43770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43771   Dali::Path *arg1 = (Dali::Path *) 0 ;
43772
43773   arg1 = (Dali::Path *)jarg1;
43774   {
43775     try {
43776       delete arg1;
43777     } catch (std::out_of_range& e) {
43778       {
43779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43780       };
43781     } catch (std::exception& e) {
43782       {
43783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43784       };
43785     } catch (Dali::DaliException e) {
43786       {
43787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43788       };
43789     } catch (...) {
43790       {
43791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43792       };
43793     }
43794   }
43795
43796 }
43797
43798
43799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43800   void * jresult ;
43801   Dali::Path *arg1 = 0 ;
43802   Dali::Path *result = 0 ;
43803
43804   arg1 = (Dali::Path *)jarg1;
43805   if (!arg1) {
43806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43807     return 0;
43808   }
43809   {
43810     try {
43811       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43812     } catch (std::out_of_range& e) {
43813       {
43814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43815       };
43816     } catch (std::exception& e) {
43817       {
43818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43819       };
43820     } catch (Dali::DaliException e) {
43821       {
43822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43823       };
43824     } catch (...) {
43825       {
43826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43827       };
43828     }
43829   }
43830
43831   jresult = (void *)result;
43832   return jresult;
43833 }
43834
43835
43836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43837   void * jresult ;
43838   Dali::Path *arg1 = (Dali::Path *) 0 ;
43839   Dali::Path *arg2 = 0 ;
43840   Dali::Path *result = 0 ;
43841
43842   arg1 = (Dali::Path *)jarg1;
43843   arg2 = (Dali::Path *)jarg2;
43844   if (!arg2) {
43845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43846     return 0;
43847   }
43848   {
43849     try {
43850       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43851     } catch (std::out_of_range& e) {
43852       {
43853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43854       };
43855     } catch (std::exception& e) {
43856       {
43857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43858       };
43859     } catch (Dali::DaliException e) {
43860       {
43861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43862       };
43863     } catch (...) {
43864       {
43865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43866       };
43867     }
43868   }
43869
43870   jresult = (void *)result;
43871   return jresult;
43872 }
43873
43874
43875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43876   Dali::Path *arg1 = (Dali::Path *) 0 ;
43877   Dali::Vector3 *arg2 = 0 ;
43878
43879   arg1 = (Dali::Path *)jarg1;
43880   arg2 = (Dali::Vector3 *)jarg2;
43881   if (!arg2) {
43882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43883     return ;
43884   }
43885   {
43886     try {
43887       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43888     } catch (std::out_of_range& e) {
43889       {
43890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43891       };
43892     } catch (std::exception& e) {
43893       {
43894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43895       };
43896     } catch (Dali::DaliException e) {
43897       {
43898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43899       };
43900     } catch (...) {
43901       {
43902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43903       };
43904     }
43905   }
43906
43907 }
43908
43909
43910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43911   Dali::Path *arg1 = (Dali::Path *) 0 ;
43912   Dali::Vector3 *arg2 = 0 ;
43913
43914   arg1 = (Dali::Path *)jarg1;
43915   arg2 = (Dali::Vector3 *)jarg2;
43916   if (!arg2) {
43917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43918     return ;
43919   }
43920   {
43921     try {
43922       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43923     } catch (std::out_of_range& e) {
43924       {
43925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43926       };
43927     } catch (std::exception& e) {
43928       {
43929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43930       };
43931     } catch (Dali::DaliException e) {
43932       {
43933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43934       };
43935     } catch (...) {
43936       {
43937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43938       };
43939     }
43940   }
43941
43942 }
43943
43944
43945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43946   Dali::Path *arg1 = (Dali::Path *) 0 ;
43947   float arg2 ;
43948
43949   arg1 = (Dali::Path *)jarg1;
43950   arg2 = (float)jarg2;
43951   {
43952     try {
43953       (arg1)->GenerateControlPoints(arg2);
43954     } catch (std::out_of_range& e) {
43955       {
43956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43957       };
43958     } catch (std::exception& e) {
43959       {
43960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43961       };
43962     } catch (Dali::DaliException e) {
43963       {
43964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43965       };
43966     } catch (...) {
43967       {
43968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43969       };
43970     }
43971   }
43972
43973 }
43974
43975
43976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43977   Dali::Path *arg1 = (Dali::Path *) 0 ;
43978   float arg2 ;
43979   Dali::Vector3 *arg3 = 0 ;
43980   Dali::Vector3 *arg4 = 0 ;
43981
43982   arg1 = (Dali::Path *)jarg1;
43983   arg2 = (float)jarg2;
43984   arg3 = (Dali::Vector3 *)jarg3;
43985   if (!arg3) {
43986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43987     return ;
43988   }
43989   arg4 = (Dali::Vector3 *)jarg4;
43990   if (!arg4) {
43991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43992     return ;
43993   }
43994   {
43995     try {
43996       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43997     } catch (std::out_of_range& e) {
43998       {
43999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44000       };
44001     } catch (std::exception& e) {
44002       {
44003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44004       };
44005     } catch (Dali::DaliException e) {
44006       {
44007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44008       };
44009     } catch (...) {
44010       {
44011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44012       };
44013     }
44014   }
44015
44016 }
44017
44018
44019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
44020   void * jresult ;
44021   Dali::Path *arg1 = (Dali::Path *) 0 ;
44022   size_t arg2 ;
44023   Dali::Vector3 *result = 0 ;
44024
44025   arg1 = (Dali::Path *)jarg1;
44026   arg2 = (size_t)jarg2;
44027   {
44028     try {
44029       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
44030     } catch (std::out_of_range& e) {
44031       {
44032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44033       };
44034     } catch (std::exception& e) {
44035       {
44036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44037       };
44038     } catch (Dali::DaliException e) {
44039       {
44040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44041       };
44042     } catch (...) {
44043       {
44044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44045       };
44046     }
44047   }
44048
44049   jresult = (void *)result;
44050   return jresult;
44051 }
44052
44053
44054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
44055   void * jresult ;
44056   Dali::Path *arg1 = (Dali::Path *) 0 ;
44057   size_t arg2 ;
44058   Dali::Vector3 *result = 0 ;
44059
44060   arg1 = (Dali::Path *)jarg1;
44061   arg2 = (size_t)jarg2;
44062   {
44063     try {
44064       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
44065     } catch (std::out_of_range& e) {
44066       {
44067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44068       };
44069     } catch (std::exception& e) {
44070       {
44071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44072       };
44073     } catch (Dali::DaliException e) {
44074       {
44075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44076       };
44077     } catch (...) {
44078       {
44079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44080       };
44081     }
44082   }
44083
44084   jresult = (void *)result;
44085   return jresult;
44086 }
44087
44088
44089 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
44090   unsigned long jresult ;
44091   Dali::Path *arg1 = (Dali::Path *) 0 ;
44092   size_t result;
44093
44094   arg1 = (Dali::Path *)jarg1;
44095   {
44096     try {
44097       result = ((Dali::Path const *)arg1)->GetPointCount();
44098     } catch (std::out_of_range& e) {
44099       {
44100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44101       };
44102     } catch (std::exception& e) {
44103       {
44104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44105       };
44106     } catch (Dali::DaliException e) {
44107       {
44108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44109       };
44110     } catch (...) {
44111       {
44112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44113       };
44114     }
44115   }
44116
44117   jresult = (unsigned long)result;
44118   return jresult;
44119 }
44120
44121
44122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
44123   void * jresult ;
44124   float arg1 ;
44125   Dali::TimePeriod *result = 0 ;
44126
44127   arg1 = (float)jarg1;
44128   {
44129     try {
44130       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
44131     } catch (std::out_of_range& e) {
44132       {
44133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44134       };
44135     } catch (std::exception& e) {
44136       {
44137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44138       };
44139     } catch (Dali::DaliException e) {
44140       {
44141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44142       };
44143     } catch (...) {
44144       {
44145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44146       };
44147     }
44148   }
44149
44150   jresult = (void *)result;
44151   return jresult;
44152 }
44153
44154
44155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
44156   void * jresult ;
44157   float arg1 ;
44158   float arg2 ;
44159   Dali::TimePeriod *result = 0 ;
44160
44161   arg1 = (float)jarg1;
44162   arg2 = (float)jarg2;
44163   {
44164     try {
44165       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
44166     } catch (std::out_of_range& e) {
44167       {
44168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44169       };
44170     } catch (std::exception& e) {
44171       {
44172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44173       };
44174     } catch (Dali::DaliException e) {
44175       {
44176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44177       };
44178     } catch (...) {
44179       {
44180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44181       };
44182     }
44183   }
44184
44185   jresult = (void *)result;
44186   return jresult;
44187 }
44188
44189
44190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
44191   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44192
44193   arg1 = (Dali::TimePeriod *)jarg1;
44194   {
44195     try {
44196       delete arg1;
44197     } catch (std::out_of_range& e) {
44198       {
44199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44200       };
44201     } catch (std::exception& e) {
44202       {
44203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44204       };
44205     } catch (Dali::DaliException e) {
44206       {
44207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44208       };
44209     } catch (...) {
44210       {
44211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44212       };
44213     }
44214   }
44215
44216 }
44217
44218
44219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
44220   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44221   float arg2 ;
44222
44223   arg1 = (Dali::TimePeriod *)jarg1;
44224   arg2 = (float)jarg2;
44225   if (arg1) (arg1)->delaySeconds = arg2;
44226 }
44227
44228
44229 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
44230   float jresult ;
44231   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44232   float result;
44233
44234   arg1 = (Dali::TimePeriod *)jarg1;
44235   result = (float) ((arg1)->delaySeconds);
44236   jresult = result;
44237   return jresult;
44238 }
44239
44240
44241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
44242   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44243   float arg2 ;
44244
44245   arg1 = (Dali::TimePeriod *)jarg1;
44246   arg2 = (float)jarg2;
44247   if (arg1) (arg1)->durationSeconds = arg2;
44248 }
44249
44250
44251 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
44252   float jresult ;
44253   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44254   float result;
44255
44256   arg1 = (Dali::TimePeriod *)jarg1;
44257   result = (float) ((arg1)->durationSeconds);
44258   jresult = result;
44259   return jresult;
44260 }
44261
44262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
44263   int jresult ;
44264   int result;
44265
44266   result = (int)Dali::LinearConstrainer::Property::VALUE;
44267   jresult = (int)result;
44268   return jresult;
44269 }
44270
44271
44272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
44273   int jresult ;
44274   int result;
44275
44276   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
44277   jresult = (int)result;
44278   return jresult;
44279 }
44280
44281
44282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
44283   void * jresult ;
44284   Dali::LinearConstrainer::Property *result = 0 ;
44285
44286   {
44287     try {
44288       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
44289     } catch (std::out_of_range& e) {
44290       {
44291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44292       };
44293     } catch (std::exception& e) {
44294       {
44295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44296       };
44297     } catch (Dali::DaliException e) {
44298       {
44299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44300       };
44301     } catch (...) {
44302       {
44303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44304       };
44305     }
44306   }
44307
44308   jresult = (void *)result;
44309   return jresult;
44310 }
44311
44312
44313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
44314   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
44315
44316   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
44317   {
44318     try {
44319       delete arg1;
44320     } catch (std::out_of_range& e) {
44321       {
44322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44323       };
44324     } catch (std::exception& e) {
44325       {
44326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44327       };
44328     } catch (Dali::DaliException e) {
44329       {
44330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44331       };
44332     } catch (...) {
44333       {
44334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44335       };
44336     }
44337   }
44338
44339 }
44340
44341
44342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
44343   void * jresult ;
44344   Dali::LinearConstrainer result;
44345
44346   {
44347     try {
44348       result = Dali::LinearConstrainer::New();
44349     } catch (std::out_of_range& e) {
44350       {
44351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44352       };
44353     } catch (std::exception& e) {
44354       {
44355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44356       };
44357     } catch (Dali::DaliException e) {
44358       {
44359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44360       };
44361     } catch (...) {
44362       {
44363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44364       };
44365     }
44366   }
44367
44368   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44369   return jresult;
44370 }
44371
44372
44373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
44374   void * jresult ;
44375   Dali::BaseHandle arg1 ;
44376   Dali::BaseHandle *argp1 ;
44377   Dali::LinearConstrainer result;
44378
44379   argp1 = (Dali::BaseHandle *)jarg1;
44380   if (!argp1) {
44381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44382     return 0;
44383   }
44384   arg1 = *argp1;
44385   {
44386     try {
44387       result = Dali::LinearConstrainer::DownCast(arg1);
44388     } catch (std::out_of_range& e) {
44389       {
44390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44391       };
44392     } catch (std::exception& e) {
44393       {
44394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44395       };
44396     } catch (Dali::DaliException e) {
44397       {
44398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44399       };
44400     } catch (...) {
44401       {
44402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44403       };
44404     }
44405   }
44406
44407   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44408   return jresult;
44409 }
44410
44411
44412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
44413   void * jresult ;
44414   Dali::LinearConstrainer *result = 0 ;
44415
44416   {
44417     try {
44418       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44419     } catch (std::out_of_range& e) {
44420       {
44421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44422       };
44423     } catch (std::exception& e) {
44424       {
44425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44426       };
44427     } catch (Dali::DaliException e) {
44428       {
44429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44430       };
44431     } catch (...) {
44432       {
44433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44434       };
44435     }
44436   }
44437
44438   jresult = (void *)result;
44439   return jresult;
44440 }
44441
44442
44443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44444   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44445
44446   arg1 = (Dali::LinearConstrainer *)jarg1;
44447   {
44448     try {
44449       delete arg1;
44450     } catch (std::out_of_range& e) {
44451       {
44452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44453       };
44454     } catch (std::exception& e) {
44455       {
44456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44457       };
44458     } catch (Dali::DaliException e) {
44459       {
44460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44461       };
44462     } catch (...) {
44463       {
44464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44465       };
44466     }
44467   }
44468
44469 }
44470
44471
44472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44473   void * jresult ;
44474   Dali::LinearConstrainer *arg1 = 0 ;
44475   Dali::LinearConstrainer *result = 0 ;
44476
44477   arg1 = (Dali::LinearConstrainer *)jarg1;
44478   if (!arg1) {
44479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44480     return 0;
44481   }
44482   {
44483     try {
44484       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44485     } catch (std::out_of_range& e) {
44486       {
44487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44488       };
44489     } catch (std::exception& e) {
44490       {
44491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44492       };
44493     } catch (Dali::DaliException e) {
44494       {
44495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44496       };
44497     } catch (...) {
44498       {
44499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44500       };
44501     }
44502   }
44503
44504   jresult = (void *)result;
44505   return jresult;
44506 }
44507
44508
44509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44510   void * jresult ;
44511   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44512   Dali::LinearConstrainer *arg2 = 0 ;
44513   Dali::LinearConstrainer *result = 0 ;
44514
44515   arg1 = (Dali::LinearConstrainer *)jarg1;
44516   arg2 = (Dali::LinearConstrainer *)jarg2;
44517   if (!arg2) {
44518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44519     return 0;
44520   }
44521   {
44522     try {
44523       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
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_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44549   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44550   SwigValueWrapper< Dali::Property > arg2 ;
44551   SwigValueWrapper< Dali::Property > arg3 ;
44552   Dali::Vector2 *arg4 = 0 ;
44553   Dali::Vector2 *arg5 = 0 ;
44554   Dali::Property *argp2 ;
44555   Dali::Property *argp3 ;
44556
44557   arg1 = (Dali::LinearConstrainer *)jarg1;
44558   argp2 = (Dali::Property *)jarg2;
44559   if (!argp2) {
44560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44561     return ;
44562   }
44563   arg2 = *argp2;
44564   argp3 = (Dali::Property *)jarg3;
44565   if (!argp3) {
44566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44567     return ;
44568   }
44569   arg3 = *argp3;
44570   arg4 = (Dali::Vector2 *)jarg4;
44571   if (!arg4) {
44572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44573     return ;
44574   }
44575   arg5 = (Dali::Vector2 *)jarg5;
44576   if (!arg5) {
44577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44578     return ;
44579   }
44580   {
44581     try {
44582       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44583     } catch (std::out_of_range& e) {
44584       {
44585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44586       };
44587     } catch (std::exception& e) {
44588       {
44589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44590       };
44591     } catch (Dali::DaliException e) {
44592       {
44593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44594       };
44595     } catch (...) {
44596       {
44597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44598       };
44599     }
44600   }
44601
44602 }
44603
44604
44605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44606   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44607   SwigValueWrapper< Dali::Property > arg2 ;
44608   SwigValueWrapper< Dali::Property > arg3 ;
44609   Dali::Vector2 *arg4 = 0 ;
44610   Dali::Property *argp2 ;
44611   Dali::Property *argp3 ;
44612
44613   arg1 = (Dali::LinearConstrainer *)jarg1;
44614   argp2 = (Dali::Property *)jarg2;
44615   if (!argp2) {
44616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44617     return ;
44618   }
44619   arg2 = *argp2;
44620   argp3 = (Dali::Property *)jarg3;
44621   if (!argp3) {
44622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44623     return ;
44624   }
44625   arg3 = *argp3;
44626   arg4 = (Dali::Vector2 *)jarg4;
44627   if (!arg4) {
44628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44629     return ;
44630   }
44631   {
44632     try {
44633       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44634     } catch (std::out_of_range& e) {
44635       {
44636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44637       };
44638     } catch (std::exception& e) {
44639       {
44640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44641       };
44642     } catch (Dali::DaliException e) {
44643       {
44644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44645       };
44646     } catch (...) {
44647       {
44648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44649       };
44650     }
44651   }
44652
44653 }
44654
44655
44656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44657   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44658   Dali::Handle *arg2 = 0 ;
44659
44660   arg1 = (Dali::LinearConstrainer *)jarg1;
44661   arg2 = (Dali::Handle *)jarg2;
44662   if (!arg2) {
44663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44664     return ;
44665   }
44666   {
44667     try {
44668       (arg1)->Remove(*arg2);
44669     } catch (std::out_of_range& e) {
44670       {
44671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44672       };
44673     } catch (std::exception& e) {
44674       {
44675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44676       };
44677     } catch (Dali::DaliException e) {
44678       {
44679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44680       };
44681     } catch (...) {
44682       {
44683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44684       };
44685     }
44686   }
44687
44688 }
44689
44690
44691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44692   int jresult ;
44693   int result;
44694
44695   result = (int)Dali::PathConstrainer::Property::FORWARD;
44696   jresult = (int)result;
44697   return jresult;
44698 }
44699
44700
44701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44702   int jresult ;
44703   int result;
44704
44705   result = (int)Dali::PathConstrainer::Property::POINTS;
44706   jresult = (int)result;
44707   return jresult;
44708 }
44709
44710
44711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44712   int jresult ;
44713   int result;
44714
44715   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44716   jresult = (int)result;
44717   return jresult;
44718 }
44719
44720
44721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44722   void * jresult ;
44723   Dali::PathConstrainer::Property *result = 0 ;
44724
44725   {
44726     try {
44727       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44728     } catch (std::out_of_range& e) {
44729       {
44730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44731       };
44732     } catch (std::exception& e) {
44733       {
44734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44735       };
44736     } catch (Dali::DaliException e) {
44737       {
44738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44739       };
44740     } catch (...) {
44741       {
44742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44743       };
44744     }
44745   }
44746
44747   jresult = (void *)result;
44748   return jresult;
44749 }
44750
44751
44752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44753   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44754
44755   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44756   {
44757     try {
44758       delete arg1;
44759     } catch (std::out_of_range& e) {
44760       {
44761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44762       };
44763     } catch (std::exception& e) {
44764       {
44765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44766       };
44767     } catch (Dali::DaliException e) {
44768       {
44769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44770       };
44771     } catch (...) {
44772       {
44773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44774       };
44775     }
44776   }
44777
44778 }
44779
44780
44781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44782   void * jresult ;
44783   Dali::PathConstrainer result;
44784
44785   {
44786     try {
44787       result = Dali::PathConstrainer::New();
44788     } catch (std::out_of_range& e) {
44789       {
44790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44791       };
44792     } catch (std::exception& e) {
44793       {
44794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44795       };
44796     } catch (Dali::DaliException e) {
44797       {
44798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44799       };
44800     } catch (...) {
44801       {
44802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44803       };
44804     }
44805   }
44806
44807   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44808   return jresult;
44809 }
44810
44811
44812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44813   void * jresult ;
44814   Dali::BaseHandle arg1 ;
44815   Dali::BaseHandle *argp1 ;
44816   Dali::PathConstrainer result;
44817
44818   argp1 = (Dali::BaseHandle *)jarg1;
44819   if (!argp1) {
44820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44821     return 0;
44822   }
44823   arg1 = *argp1;
44824   {
44825     try {
44826       result = Dali::PathConstrainer::DownCast(arg1);
44827     } catch (std::out_of_range& e) {
44828       {
44829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44830       };
44831     } catch (std::exception& e) {
44832       {
44833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44834       };
44835     } catch (Dali::DaliException e) {
44836       {
44837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44838       };
44839     } catch (...) {
44840       {
44841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44842       };
44843     }
44844   }
44845
44846   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44847   return jresult;
44848 }
44849
44850
44851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44852   void * jresult ;
44853   Dali::PathConstrainer *result = 0 ;
44854
44855   {
44856     try {
44857       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44858     } catch (std::out_of_range& e) {
44859       {
44860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44861       };
44862     } catch (std::exception& e) {
44863       {
44864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44865       };
44866     } catch (Dali::DaliException e) {
44867       {
44868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44869       };
44870     } catch (...) {
44871       {
44872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44873       };
44874     }
44875   }
44876
44877   jresult = (void *)result;
44878   return jresult;
44879 }
44880
44881
44882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44883   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44884
44885   arg1 = (Dali::PathConstrainer *)jarg1;
44886   {
44887     try {
44888       delete arg1;
44889     } catch (std::out_of_range& e) {
44890       {
44891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44892       };
44893     } catch (std::exception& e) {
44894       {
44895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44896       };
44897     } catch (Dali::DaliException e) {
44898       {
44899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44900       };
44901     } catch (...) {
44902       {
44903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44904       };
44905     }
44906   }
44907
44908 }
44909
44910
44911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44912   void * jresult ;
44913   Dali::PathConstrainer *arg1 = 0 ;
44914   Dali::PathConstrainer *result = 0 ;
44915
44916   arg1 = (Dali::PathConstrainer *)jarg1;
44917   if (!arg1) {
44918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44919     return 0;
44920   }
44921   {
44922     try {
44923       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44924     } catch (std::out_of_range& e) {
44925       {
44926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44927       };
44928     } catch (std::exception& e) {
44929       {
44930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44931       };
44932     } catch (Dali::DaliException e) {
44933       {
44934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44935       };
44936     } catch (...) {
44937       {
44938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44939       };
44940     }
44941   }
44942
44943   jresult = (void *)result;
44944   return jresult;
44945 }
44946
44947
44948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44949   void * jresult ;
44950   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44951   Dali::PathConstrainer *arg2 = 0 ;
44952   Dali::PathConstrainer *result = 0 ;
44953
44954   arg1 = (Dali::PathConstrainer *)jarg1;
44955   arg2 = (Dali::PathConstrainer *)jarg2;
44956   if (!arg2) {
44957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44958     return 0;
44959   }
44960   {
44961     try {
44962       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44963     } catch (std::out_of_range& e) {
44964       {
44965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44966       };
44967     } catch (std::exception& e) {
44968       {
44969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44970       };
44971     } catch (Dali::DaliException e) {
44972       {
44973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44974       };
44975     } catch (...) {
44976       {
44977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44978       };
44979     }
44980   }
44981
44982   jresult = (void *)result;
44983   return jresult;
44984 }
44985
44986
44987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44988   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44989   SwigValueWrapper< Dali::Property > arg2 ;
44990   SwigValueWrapper< Dali::Property > arg3 ;
44991   Dali::Vector2 *arg4 = 0 ;
44992   Dali::Vector2 *arg5 = 0 ;
44993   Dali::Property *argp2 ;
44994   Dali::Property *argp3 ;
44995
44996   arg1 = (Dali::PathConstrainer *)jarg1;
44997   argp2 = (Dali::Property *)jarg2;
44998   if (!argp2) {
44999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
45000     return ;
45001   }
45002   arg2 = *argp2;
45003   argp3 = (Dali::Property *)jarg3;
45004   if (!argp3) {
45005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
45006     return ;
45007   }
45008   arg3 = *argp3;
45009   arg4 = (Dali::Vector2 *)jarg4;
45010   if (!arg4) {
45011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45012     return ;
45013   }
45014   arg5 = (Dali::Vector2 *)jarg5;
45015   if (!arg5) {
45016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45017     return ;
45018   }
45019   {
45020     try {
45021       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
45022     } catch (std::out_of_range& e) {
45023       {
45024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45025       };
45026     } catch (std::exception& e) {
45027       {
45028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45029       };
45030     } catch (Dali::DaliException e) {
45031       {
45032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45033       };
45034     } catch (...) {
45035       {
45036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45037       };
45038     }
45039   }
45040
45041 }
45042
45043
45044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
45045   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
45046   SwigValueWrapper< Dali::Property > arg2 ;
45047   SwigValueWrapper< Dali::Property > arg3 ;
45048   Dali::Vector2 *arg4 = 0 ;
45049   Dali::Property *argp2 ;
45050   Dali::Property *argp3 ;
45051
45052   arg1 = (Dali::PathConstrainer *)jarg1;
45053   argp2 = (Dali::Property *)jarg2;
45054   if (!argp2) {
45055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
45056     return ;
45057   }
45058   arg2 = *argp2;
45059   argp3 = (Dali::Property *)jarg3;
45060   if (!argp3) {
45061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
45062     return ;
45063   }
45064   arg3 = *argp3;
45065   arg4 = (Dali::Vector2 *)jarg4;
45066   if (!arg4) {
45067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45068     return ;
45069   }
45070   {
45071     try {
45072       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
45073     } catch (std::out_of_range& e) {
45074       {
45075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45076       };
45077     } catch (std::exception& e) {
45078       {
45079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45080       };
45081     } catch (Dali::DaliException e) {
45082       {
45083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45084       };
45085     } catch (...) {
45086       {
45087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45088       };
45089     }
45090   }
45091
45092 }
45093
45094
45095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
45096   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
45097   Dali::Handle *arg2 = 0 ;
45098
45099   arg1 = (Dali::PathConstrainer *)jarg1;
45100   arg2 = (Dali::Handle *)jarg2;
45101   if (!arg2) {
45102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
45103     return ;
45104   }
45105   {
45106     try {
45107       (arg1)->Remove(*arg2);
45108     } catch (std::out_of_range& e) {
45109       {
45110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45111       };
45112     } catch (std::exception& e) {
45113       {
45114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45115       };
45116     } catch (Dali::DaliException e) {
45117       {
45118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45119       };
45120     } catch (...) {
45121       {
45122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45123       };
45124     }
45125   }
45126
45127 }
45128
45129
45130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
45131   int jresult ;
45132   Dali::FittingMode::Type result;
45133
45134   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
45135   jresult = (int)result;
45136   return jresult;
45137 }
45138
45139
45140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
45141   int jresult ;
45142   Dali::SamplingMode::Type result;
45143
45144   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
45145   jresult = (int)result;
45146   return jresult;
45147 }
45148
45149
45150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
45151   void * jresult ;
45152   Dali::BufferImage *result = 0 ;
45153
45154   {
45155     try {
45156       result = (Dali::BufferImage *)new Dali::BufferImage();
45157     } catch (std::out_of_range& e) {
45158       {
45159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45160       };
45161     } catch (std::exception& e) {
45162       {
45163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45164       };
45165     } catch (Dali::DaliException e) {
45166       {
45167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45168       };
45169     } catch (...) {
45170       {
45171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45172       };
45173     }
45174   }
45175
45176   jresult = (void *)result;
45177   return jresult;
45178 }
45179
45180
45181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
45182   void * jresult ;
45183   unsigned int arg1 ;
45184   unsigned int arg2 ;
45185   Dali::Pixel::Format arg3 ;
45186   Dali::BufferImage result;
45187
45188   arg1 = (unsigned int)jarg1;
45189   arg2 = (unsigned int)jarg2;
45190   arg3 = (Dali::Pixel::Format)jarg3;
45191   {
45192     try {
45193       result = Dali::BufferImage::New(arg1,arg2,arg3);
45194     } catch (std::out_of_range& e) {
45195       {
45196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45197       };
45198     } catch (std::exception& e) {
45199       {
45200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45201       };
45202     } catch (Dali::DaliException e) {
45203       {
45204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45205       };
45206     } catch (...) {
45207       {
45208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45209       };
45210     }
45211   }
45212
45213   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45214   return jresult;
45215 }
45216
45217
45218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
45219   void * jresult ;
45220   unsigned int arg1 ;
45221   unsigned int arg2 ;
45222   Dali::BufferImage result;
45223
45224   arg1 = (unsigned int)jarg1;
45225   arg2 = (unsigned int)jarg2;
45226   {
45227     try {
45228       result = Dali::BufferImage::New(arg1,arg2);
45229     } catch (std::out_of_range& e) {
45230       {
45231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45232       };
45233     } catch (std::exception& e) {
45234       {
45235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45236       };
45237     } catch (Dali::DaliException e) {
45238       {
45239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45240       };
45241     } catch (...) {
45242       {
45243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45244       };
45245     }
45246   }
45247
45248   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45249   return jresult;
45250 }
45251
45252
45253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
45254   void * jresult ;
45255   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45256   unsigned int arg2 ;
45257   unsigned int arg3 ;
45258   Dali::Pixel::Format arg4 ;
45259   unsigned int arg5 ;
45260   Dali::BufferImage result;
45261
45262   arg1 = jarg1;
45263   arg2 = (unsigned int)jarg2;
45264   arg3 = (unsigned int)jarg3;
45265   arg4 = (Dali::Pixel::Format)jarg4;
45266   arg5 = (unsigned int)jarg5;
45267   {
45268     try {
45269       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
45270     } catch (std::out_of_range& e) {
45271       {
45272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45273       };
45274     } catch (std::exception& e) {
45275       {
45276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45277       };
45278     } catch (Dali::DaliException e) {
45279       {
45280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45281       };
45282     } catch (...) {
45283       {
45284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45285       };
45286     }
45287   }
45288
45289   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45290
45291
45292   return jresult;
45293 }
45294
45295
45296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
45297   void * jresult ;
45298   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45299   unsigned int arg2 ;
45300   unsigned int arg3 ;
45301   Dali::Pixel::Format arg4 ;
45302   Dali::BufferImage result;
45303
45304   arg1 = jarg1;
45305   arg2 = (unsigned int)jarg2;
45306   arg3 = (unsigned int)jarg3;
45307   arg4 = (Dali::Pixel::Format)jarg4;
45308   {
45309     try {
45310       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
45311     } catch (std::out_of_range& e) {
45312       {
45313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45314       };
45315     } catch (std::exception& e) {
45316       {
45317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45318       };
45319     } catch (Dali::DaliException e) {
45320       {
45321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45322       };
45323     } catch (...) {
45324       {
45325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45326       };
45327     }
45328   }
45329
45330   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45331
45332
45333   return jresult;
45334 }
45335
45336
45337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
45338   void * jresult ;
45339   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45340   unsigned int arg2 ;
45341   unsigned int arg3 ;
45342   Dali::BufferImage result;
45343
45344   arg1 = jarg1;
45345   arg2 = (unsigned int)jarg2;
45346   arg3 = (unsigned int)jarg3;
45347   {
45348     try {
45349       result = Dali::BufferImage::New(arg1,arg2,arg3);
45350     } catch (std::out_of_range& e) {
45351       {
45352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45353       };
45354     } catch (std::exception& e) {
45355       {
45356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45357       };
45358     } catch (Dali::DaliException e) {
45359       {
45360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45361       };
45362     } catch (...) {
45363       {
45364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45365       };
45366     }
45367   }
45368
45369   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45370
45371
45372   return jresult;
45373 }
45374
45375
45376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
45377   void * jresult ;
45378   Dali::BaseHandle arg1 ;
45379   Dali::BaseHandle *argp1 ;
45380   Dali::BufferImage result;
45381
45382   argp1 = (Dali::BaseHandle *)jarg1;
45383   if (!argp1) {
45384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45385     return 0;
45386   }
45387   arg1 = *argp1;
45388   {
45389     try {
45390       result = Dali::BufferImage::DownCast(arg1);
45391     } catch (std::out_of_range& e) {
45392       {
45393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45394       };
45395     } catch (std::exception& e) {
45396       {
45397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45398       };
45399     } catch (Dali::DaliException e) {
45400       {
45401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45402       };
45403     } catch (...) {
45404       {
45405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45406       };
45407     }
45408   }
45409
45410   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45411   return jresult;
45412 }
45413
45414
45415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
45416   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45417
45418   arg1 = (Dali::BufferImage *)jarg1;
45419   {
45420     try {
45421       delete arg1;
45422     } catch (std::out_of_range& e) {
45423       {
45424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45425       };
45426     } catch (std::exception& e) {
45427       {
45428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45429       };
45430     } catch (Dali::DaliException e) {
45431       {
45432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45433       };
45434     } catch (...) {
45435       {
45436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45437       };
45438     }
45439   }
45440
45441 }
45442
45443
45444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
45445   void * jresult ;
45446   Dali::BufferImage *arg1 = 0 ;
45447   Dali::BufferImage *result = 0 ;
45448
45449   arg1 = (Dali::BufferImage *)jarg1;
45450   if (!arg1) {
45451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45452     return 0;
45453   }
45454   {
45455     try {
45456       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
45457     } catch (std::out_of_range& e) {
45458       {
45459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45460       };
45461     } catch (std::exception& e) {
45462       {
45463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45464       };
45465     } catch (Dali::DaliException e) {
45466       {
45467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45468       };
45469     } catch (...) {
45470       {
45471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45472       };
45473     }
45474   }
45475
45476   jresult = (void *)result;
45477   return jresult;
45478 }
45479
45480
45481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
45482   void * jresult ;
45483   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45484   Dali::BufferImage *arg2 = 0 ;
45485   Dali::BufferImage *result = 0 ;
45486
45487   arg1 = (Dali::BufferImage *)jarg1;
45488   arg2 = (Dali::BufferImage *)jarg2;
45489   if (!arg2) {
45490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45491     return 0;
45492   }
45493   {
45494     try {
45495       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
45496     } catch (std::out_of_range& e) {
45497       {
45498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45499       };
45500     } catch (std::exception& e) {
45501       {
45502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45503       };
45504     } catch (Dali::DaliException e) {
45505       {
45506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45507       };
45508     } catch (...) {
45509       {
45510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45511       };
45512     }
45513   }
45514
45515   jresult = (void *)result;
45516   return jresult;
45517 }
45518
45519
45520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
45521   void * jresult ;
45522   Dali::BufferImage result;
45523
45524   {
45525     try {
45526       result = Dali::BufferImage::WHITE();
45527     } catch (std::out_of_range& e) {
45528       {
45529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45530       };
45531     } catch (std::exception& e) {
45532       {
45533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45534       };
45535     } catch (Dali::DaliException e) {
45536       {
45537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45538       };
45539     } catch (...) {
45540       {
45541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45542       };
45543     }
45544   }
45545
45546   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45547   return jresult;
45548 }
45549
45550
45551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
45552   void * jresult ;
45553   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45554   Dali::PixelBuffer *result = 0 ;
45555
45556   arg1 = (Dali::BufferImage *)jarg1;
45557   {
45558     try {
45559       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
45560     } catch (std::out_of_range& e) {
45561       {
45562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45563       };
45564     } catch (std::exception& e) {
45565       {
45566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45567       };
45568     } catch (Dali::DaliException e) {
45569       {
45570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45571       };
45572     } catch (...) {
45573       {
45574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45575       };
45576     }
45577   }
45578
45579   jresult = (void *)result;
45580   return jresult;
45581 }
45582
45583
45584 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
45585   unsigned int jresult ;
45586   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45587   unsigned int result;
45588
45589   arg1 = (Dali::BufferImage *)jarg1;
45590   {
45591     try {
45592       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
45593     } catch (std::out_of_range& e) {
45594       {
45595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45596       };
45597     } catch (std::exception& e) {
45598       {
45599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45600       };
45601     } catch (Dali::DaliException e) {
45602       {
45603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45604       };
45605     } catch (...) {
45606       {
45607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45608       };
45609     }
45610   }
45611
45612   jresult = result;
45613   return jresult;
45614 }
45615
45616
45617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
45618   unsigned int jresult ;
45619   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45620   unsigned int result;
45621
45622   arg1 = (Dali::BufferImage *)jarg1;
45623   {
45624     try {
45625       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
45626     } catch (std::out_of_range& e) {
45627       {
45628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45629       };
45630     } catch (std::exception& e) {
45631       {
45632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45633       };
45634     } catch (Dali::DaliException e) {
45635       {
45636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45637       };
45638     } catch (...) {
45639       {
45640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45641       };
45642     }
45643   }
45644
45645   jresult = result;
45646   return jresult;
45647 }
45648
45649
45650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
45651   int jresult ;
45652   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45653   Dali::Pixel::Format result;
45654
45655   arg1 = (Dali::BufferImage *)jarg1;
45656   {
45657     try {
45658       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
45659     } catch (std::out_of_range& e) {
45660       {
45661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45662       };
45663     } catch (std::exception& e) {
45664       {
45665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45666       };
45667     } catch (Dali::DaliException e) {
45668       {
45669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45670       };
45671     } catch (...) {
45672       {
45673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45674       };
45675     }
45676   }
45677
45678   jresult = (int)result;
45679   return jresult;
45680 }
45681
45682
45683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
45684   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45685
45686   arg1 = (Dali::BufferImage *)jarg1;
45687   {
45688     try {
45689       (arg1)->Update();
45690     } catch (std::out_of_range& e) {
45691       {
45692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45693       };
45694     } catch (std::exception& e) {
45695       {
45696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45697       };
45698     } catch (Dali::DaliException e) {
45699       {
45700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45701       };
45702     } catch (...) {
45703       {
45704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45705       };
45706     }
45707   }
45708
45709 }
45710
45711
45712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
45713   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45714   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
45715   Dali::RectArea *argp2 ;
45716
45717   arg1 = (Dali::BufferImage *)jarg1;
45718   argp2 = (Dali::RectArea *)jarg2;
45719   if (!argp2) {
45720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
45721     return ;
45722   }
45723   arg2 = *argp2;
45724   {
45725     try {
45726       (arg1)->Update(arg2);
45727     } catch (std::out_of_range& e) {
45728       {
45729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45730       };
45731     } catch (std::exception& e) {
45732       {
45733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45734       };
45735     } catch (Dali::DaliException e) {
45736       {
45737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45738       };
45739     } catch (...) {
45740       {
45741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45742       };
45743     }
45744   }
45745
45746 }
45747
45748
45749 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
45750   unsigned int jresult ;
45751   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45752   bool result;
45753
45754   arg1 = (Dali::BufferImage *)jarg1;
45755   {
45756     try {
45757       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
45758     } catch (std::out_of_range& e) {
45759       {
45760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45761       };
45762     } catch (std::exception& e) {
45763       {
45764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45765       };
45766     } catch (Dali::DaliException e) {
45767       {
45768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45769       };
45770     } catch (...) {
45771       {
45772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45773       };
45774     }
45775   }
45776
45777   jresult = result;
45778   return jresult;
45779 }
45780
45781
45782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
45783   void * jresult ;
45784   Dali::EncodedBufferImage *result = 0 ;
45785
45786   {
45787     try {
45788       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
45789     } catch (std::out_of_range& e) {
45790       {
45791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45792       };
45793     } catch (std::exception& e) {
45794       {
45795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45796       };
45797     } catch (Dali::DaliException e) {
45798       {
45799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45800       };
45801     } catch (...) {
45802       {
45803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45804       };
45805     }
45806   }
45807
45808   jresult = (void *)result;
45809   return jresult;
45810 }
45811
45812
45813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
45814   void * jresult ;
45815   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45816   std::size_t arg2 ;
45817   Dali::EncodedBufferImage result;
45818
45819   arg1 = (uint8_t *)jarg1;
45820   arg2 = (std::size_t)jarg2;
45821   {
45822     try {
45823       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
45824     } catch (std::out_of_range& e) {
45825       {
45826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45827       };
45828     } catch (std::exception& e) {
45829       {
45830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45831       };
45832     } catch (Dali::DaliException e) {
45833       {
45834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45835       };
45836     } catch (...) {
45837       {
45838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45839       };
45840     }
45841   }
45842
45843   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45844   return jresult;
45845 }
45846
45847
45848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
45849   void * jresult ;
45850   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45851   std::size_t arg2 ;
45852   Dali::ImageDimensions arg3 ;
45853   Dali::FittingMode::Type arg4 ;
45854   Dali::SamplingMode::Type arg5 ;
45855   bool arg6 ;
45856   Dali::ImageDimensions *argp3 ;
45857   Dali::EncodedBufferImage result;
45858
45859   arg1 = (uint8_t *)jarg1;
45860   arg2 = (std::size_t)jarg2;
45861   argp3 = (Dali::ImageDimensions *)jarg3;
45862   if (!argp3) {
45863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45864     return 0;
45865   }
45866   arg3 = *argp3;
45867   arg4 = (Dali::FittingMode::Type)jarg4;
45868   arg5 = (Dali::SamplingMode::Type)jarg5;
45869   arg6 = jarg6 ? true : false;
45870   {
45871     try {
45872       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
45873     } catch (std::out_of_range& e) {
45874       {
45875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45876       };
45877     } catch (std::exception& e) {
45878       {
45879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45880       };
45881     } catch (Dali::DaliException e) {
45882       {
45883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45884       };
45885     } catch (...) {
45886       {
45887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45888       };
45889     }
45890   }
45891
45892   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45893   return jresult;
45894 }
45895
45896
45897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
45898   void * jresult ;
45899   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45900   std::size_t arg2 ;
45901   Dali::ImageDimensions arg3 ;
45902   Dali::FittingMode::Type arg4 ;
45903   Dali::SamplingMode::Type arg5 ;
45904   Dali::ImageDimensions *argp3 ;
45905   Dali::EncodedBufferImage result;
45906
45907   arg1 = (uint8_t *)jarg1;
45908   arg2 = (std::size_t)jarg2;
45909   argp3 = (Dali::ImageDimensions *)jarg3;
45910   if (!argp3) {
45911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45912     return 0;
45913   }
45914   arg3 = *argp3;
45915   arg4 = (Dali::FittingMode::Type)jarg4;
45916   arg5 = (Dali::SamplingMode::Type)jarg5;
45917   {
45918     try {
45919       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
45920     } catch (std::out_of_range& e) {
45921       {
45922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45923       };
45924     } catch (std::exception& e) {
45925       {
45926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45927       };
45928     } catch (Dali::DaliException e) {
45929       {
45930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45931       };
45932     } catch (...) {
45933       {
45934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45935       };
45936     }
45937   }
45938
45939   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45940   return jresult;
45941 }
45942
45943
45944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
45945   void * jresult ;
45946   Dali::BaseHandle arg1 ;
45947   Dali::BaseHandle *argp1 ;
45948   Dali::EncodedBufferImage result;
45949
45950   argp1 = (Dali::BaseHandle *)jarg1;
45951   if (!argp1) {
45952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45953     return 0;
45954   }
45955   arg1 = *argp1;
45956   {
45957     try {
45958       result = Dali::EncodedBufferImage::DownCast(arg1);
45959     } catch (std::out_of_range& e) {
45960       {
45961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45962       };
45963     } catch (std::exception& e) {
45964       {
45965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45966       };
45967     } catch (Dali::DaliException e) {
45968       {
45969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45970       };
45971     } catch (...) {
45972       {
45973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45974       };
45975     }
45976   }
45977
45978   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45979   return jresult;
45980 }
45981
45982
45983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
45984   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45985
45986   arg1 = (Dali::EncodedBufferImage *)jarg1;
45987   {
45988     try {
45989       delete arg1;
45990     } catch (std::out_of_range& e) {
45991       {
45992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45993       };
45994     } catch (std::exception& e) {
45995       {
45996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45997       };
45998     } catch (Dali::DaliException e) {
45999       {
46000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46001       };
46002     } catch (...) {
46003       {
46004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46005       };
46006     }
46007   }
46008
46009 }
46010
46011
46012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
46013   void * jresult ;
46014   Dali::EncodedBufferImage *arg1 = 0 ;
46015   Dali::EncodedBufferImage *result = 0 ;
46016
46017   arg1 = (Dali::EncodedBufferImage *)jarg1;
46018   if (!arg1) {
46019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
46020     return 0;
46021   }
46022   {
46023     try {
46024       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
46025     } catch (std::out_of_range& e) {
46026       {
46027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46028       };
46029     } catch (std::exception& e) {
46030       {
46031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46032       };
46033     } catch (Dali::DaliException e) {
46034       {
46035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46036       };
46037     } catch (...) {
46038       {
46039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46040       };
46041     }
46042   }
46043
46044   jresult = (void *)result;
46045   return jresult;
46046 }
46047
46048
46049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
46050   void * jresult ;
46051   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
46052   Dali::EncodedBufferImage *arg2 = 0 ;
46053   Dali::EncodedBufferImage *result = 0 ;
46054
46055   arg1 = (Dali::EncodedBufferImage *)jarg1;
46056   arg2 = (Dali::EncodedBufferImage *)jarg2;
46057   if (!arg2) {
46058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
46059     return 0;
46060   }
46061   {
46062     try {
46063       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
46064     } catch (std::out_of_range& e) {
46065       {
46066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46067       };
46068     } catch (std::exception& e) {
46069       {
46070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46071       };
46072     } catch (Dali::DaliException e) {
46073       {
46074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46075       };
46076     } catch (...) {
46077       {
46078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46079       };
46080     }
46081   }
46082
46083   jresult = (void *)result;
46084   return jresult;
46085 }
46086
46087
46088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
46089   void * jresult ;
46090   Dali::NativeImage *result = 0 ;
46091
46092   {
46093     try {
46094       result = (Dali::NativeImage *)new Dali::NativeImage();
46095     } catch (std::out_of_range& e) {
46096       {
46097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46098       };
46099     } catch (std::exception& e) {
46100       {
46101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46102       };
46103     } catch (Dali::DaliException e) {
46104       {
46105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46106       };
46107     } catch (...) {
46108       {
46109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46110       };
46111     }
46112   }
46113
46114   jresult = (void *)result;
46115   return jresult;
46116 }
46117
46118
46119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
46120   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46121
46122   arg1 = (Dali::NativeImage *)jarg1;
46123   {
46124     try {
46125       delete arg1;
46126     } catch (std::out_of_range& e) {
46127       {
46128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46129       };
46130     } catch (std::exception& e) {
46131       {
46132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46133       };
46134     } catch (Dali::DaliException e) {
46135       {
46136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46137       };
46138     } catch (...) {
46139       {
46140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46141       };
46142     }
46143   }
46144
46145 }
46146
46147
46148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
46149   void * jresult ;
46150   Dali::NativeImage *arg1 = 0 ;
46151   Dali::NativeImage *result = 0 ;
46152
46153   arg1 = (Dali::NativeImage *)jarg1;
46154   if (!arg1) {
46155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46156     return 0;
46157   }
46158   {
46159     try {
46160       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
46161     } catch (std::out_of_range& e) {
46162       {
46163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46164       };
46165     } catch (std::exception& e) {
46166       {
46167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46168       };
46169     } catch (Dali::DaliException e) {
46170       {
46171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46172       };
46173     } catch (...) {
46174       {
46175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46176       };
46177     }
46178   }
46179
46180   jresult = (void *)result;
46181   return jresult;
46182 }
46183
46184
46185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
46186   void * jresult ;
46187   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46188   Dali::NativeImage *arg2 = 0 ;
46189   Dali::NativeImage *result = 0 ;
46190
46191   arg1 = (Dali::NativeImage *)jarg1;
46192   arg2 = (Dali::NativeImage *)jarg2;
46193   if (!arg2) {
46194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46195     return 0;
46196   }
46197   {
46198     try {
46199       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
46200     } catch (std::out_of_range& e) {
46201       {
46202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46203       };
46204     } catch (std::exception& e) {
46205       {
46206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46207       };
46208     } catch (Dali::DaliException e) {
46209       {
46210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46211       };
46212     } catch (...) {
46213       {
46214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46215       };
46216     }
46217   }
46218
46219   jresult = (void *)result;
46220   return jresult;
46221 }
46222
46223
46224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
46225   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46226
46227   arg1 = (Dali::NativeImage *)jarg1;
46228   {
46229     try {
46230       (arg1)->CreateGlTexture();
46231     } catch (std::out_of_range& e) {
46232       {
46233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46234       };
46235     } catch (std::exception& e) {
46236       {
46237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46238       };
46239     } catch (Dali::DaliException e) {
46240       {
46241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46242       };
46243     } catch (...) {
46244       {
46245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46246       };
46247     }
46248   }
46249
46250 }
46251
46252
46253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
46254   void * jresult ;
46255   NativeImageInterface *arg1 = 0 ;
46256   Dali::NativeImage result;
46257
46258   arg1 = (NativeImageInterface *)jarg1;
46259   if (!arg1) {
46260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
46261     return 0;
46262   }
46263   {
46264     try {
46265       result = Dali::NativeImage::New(*arg1);
46266     } catch (std::out_of_range& e) {
46267       {
46268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46269       };
46270     } catch (std::exception& e) {
46271       {
46272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46273       };
46274     } catch (Dali::DaliException e) {
46275       {
46276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46277       };
46278     } catch (...) {
46279       {
46280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46281       };
46282     }
46283   }
46284
46285   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46286   return jresult;
46287 }
46288
46289
46290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
46291   void * jresult ;
46292   Dali::BaseHandle arg1 ;
46293   Dali::BaseHandle *argp1 ;
46294   Dali::NativeImage result;
46295
46296   argp1 = (Dali::BaseHandle *)jarg1;
46297   if (!argp1) {
46298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46299     return 0;
46300   }
46301   arg1 = *argp1;
46302   {
46303     try {
46304       result = Dali::NativeImage::DownCast(arg1);
46305     } catch (std::out_of_range& e) {
46306       {
46307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46308       };
46309     } catch (std::exception& e) {
46310       {
46311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46312       };
46313     } catch (Dali::DaliException e) {
46314       {
46315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46316       };
46317     } catch (...) {
46318       {
46319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46320       };
46321     }
46322   }
46323
46324   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46325   return jresult;
46326 }
46327
46328
46329 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
46330   char * jresult ;
46331   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46332   char *result = 0 ;
46333
46334   arg1 = (Dali::NativeImage *)jarg1;
46335   {
46336     try {
46337       result = (char *)(arg1)->GetCustomFragmentPreFix();
46338     } catch (std::out_of_range& e) {
46339       {
46340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46341       };
46342     } catch (std::exception& e) {
46343       {
46344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46345       };
46346     } catch (Dali::DaliException e) {
46347       {
46348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46349       };
46350     } catch (...) {
46351       {
46352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46353       };
46354     }
46355   }
46356
46357   jresult = SWIG_csharp_string_callback((const char *)result);
46358   return jresult;
46359 }
46360
46361
46362 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
46363   char * jresult ;
46364   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46365   char *result = 0 ;
46366
46367   arg1 = (Dali::NativeImage *)jarg1;
46368   {
46369     try {
46370       result = (char *)(arg1)->GetCustomSamplerTypename();
46371     } catch (std::out_of_range& e) {
46372       {
46373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46374       };
46375     } catch (std::exception& e) {
46376       {
46377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46378       };
46379     } catch (Dali::DaliException e) {
46380       {
46381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46382       };
46383     } catch (...) {
46384       {
46385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46386       };
46387     }
46388   }
46389
46390   jresult = SWIG_csharp_string_callback((const char *)result);
46391   return jresult;
46392 }
46393
46394
46395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
46396   unsigned int jresult ;
46397   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46398   bool result;
46399
46400   arg1 = (Dali::NativeImageInterface *)jarg1;
46401   {
46402     try {
46403       result = (bool)(arg1)->GlExtensionCreate();
46404     } catch (std::out_of_range& e) {
46405       {
46406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46407       };
46408     } catch (std::exception& e) {
46409       {
46410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46411       };
46412     } catch (Dali::DaliException e) {
46413       {
46414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46415       };
46416     } catch (...) {
46417       {
46418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46419       };
46420     }
46421   }
46422
46423   jresult = result;
46424   return jresult;
46425 }
46426
46427
46428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
46429   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46430
46431   arg1 = (Dali::NativeImageInterface *)jarg1;
46432   {
46433     try {
46434       (arg1)->GlExtensionDestroy();
46435     } catch (std::out_of_range& e) {
46436       {
46437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46438       };
46439     } catch (std::exception& e) {
46440       {
46441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46442       };
46443     } catch (Dali::DaliException e) {
46444       {
46445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46446       };
46447     } catch (...) {
46448       {
46449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46450       };
46451     }
46452   }
46453
46454 }
46455
46456
46457 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
46458   unsigned int jresult ;
46459   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46460   unsigned int result;
46461
46462   arg1 = (Dali::NativeImageInterface *)jarg1;
46463   {
46464     try {
46465       result = (unsigned int)(arg1)->TargetTexture();
46466     } catch (std::out_of_range& e) {
46467       {
46468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46469       };
46470     } catch (std::exception& e) {
46471       {
46472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46473       };
46474     } catch (Dali::DaliException e) {
46475       {
46476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46477       };
46478     } catch (...) {
46479       {
46480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46481       };
46482     }
46483   }
46484
46485   jresult = result;
46486   return jresult;
46487 }
46488
46489
46490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
46491   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46492
46493   arg1 = (Dali::NativeImageInterface *)jarg1;
46494   {
46495     try {
46496       (arg1)->PrepareTexture();
46497     } catch (std::out_of_range& e) {
46498       {
46499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46500       };
46501     } catch (std::exception& e) {
46502       {
46503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46504       };
46505     } catch (Dali::DaliException e) {
46506       {
46507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46508       };
46509     } catch (...) {
46510       {
46511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46512       };
46513     }
46514   }
46515
46516 }
46517
46518
46519 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
46520   unsigned int jresult ;
46521   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46522   unsigned int result;
46523
46524   arg1 = (Dali::NativeImageInterface *)jarg1;
46525   {
46526     try {
46527       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
46528     } catch (std::out_of_range& e) {
46529       {
46530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46531       };
46532     } catch (std::exception& e) {
46533       {
46534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46535       };
46536     } catch (Dali::DaliException e) {
46537       {
46538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46539       };
46540     } catch (...) {
46541       {
46542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46543       };
46544     }
46545   }
46546
46547   jresult = result;
46548   return jresult;
46549 }
46550
46551
46552 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
46553   unsigned int jresult ;
46554   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46555   unsigned int result;
46556
46557   arg1 = (Dali::NativeImageInterface *)jarg1;
46558   {
46559     try {
46560       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
46561     } catch (std::out_of_range& e) {
46562       {
46563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46564       };
46565     } catch (std::exception& e) {
46566       {
46567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46568       };
46569     } catch (Dali::DaliException e) {
46570       {
46571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46572       };
46573     } catch (...) {
46574       {
46575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46576       };
46577     }
46578   }
46579
46580   jresult = result;
46581   return jresult;
46582 }
46583
46584
46585 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
46586   unsigned int jresult ;
46587   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46588   bool result;
46589
46590   arg1 = (Dali::NativeImageInterface *)jarg1;
46591   {
46592     try {
46593       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
46594     } catch (std::out_of_range& e) {
46595       {
46596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46597       };
46598     } catch (std::exception& e) {
46599       {
46600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46601       };
46602     } catch (Dali::DaliException e) {
46603       {
46604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46605       };
46606     } catch (...) {
46607       {
46608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46609       };
46610     }
46611   }
46612
46613   jresult = result;
46614   return jresult;
46615 }
46616
46617
46618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
46619   void * jresult ;
46620   std::string *arg1 = 0 ;
46621   Dali::ImageDimensions result;
46622
46623   if (!jarg1) {
46624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46625     return 0;
46626   }
46627   std::string arg1_str(jarg1);
46628   arg1 = &arg1_str;
46629   {
46630     try {
46631       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
46632     } catch (std::out_of_range& e) {
46633       {
46634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46635       };
46636     } catch (std::exception& e) {
46637       {
46638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46639       };
46640     } catch (Dali::DaliException e) {
46641       {
46642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46643       };
46644     } catch (...) {
46645       {
46646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46647       };
46648     }
46649   }
46650
46651   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
46652
46653   //argout typemap for const std::string&
46654
46655   return jresult;
46656 }
46657
46658
46659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
46660   void * jresult ;
46661   Dali::ResourceImage *result = 0 ;
46662
46663   {
46664     try {
46665       result = (Dali::ResourceImage *)new Dali::ResourceImage();
46666     } catch (std::out_of_range& e) {
46667       {
46668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46669       };
46670     } catch (std::exception& e) {
46671       {
46672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46673       };
46674     } catch (Dali::DaliException e) {
46675       {
46676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46677       };
46678     } catch (...) {
46679       {
46680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46681       };
46682     }
46683   }
46684
46685   jresult = (void *)result;
46686   return jresult;
46687 }
46688
46689
46690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
46691   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46692
46693   arg1 = (Dali::ResourceImage *)jarg1;
46694   {
46695     try {
46696       delete arg1;
46697     } catch (std::out_of_range& e) {
46698       {
46699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46700       };
46701     } catch (std::exception& e) {
46702       {
46703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46704       };
46705     } catch (Dali::DaliException e) {
46706       {
46707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46708       };
46709     } catch (...) {
46710       {
46711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46712       };
46713     }
46714   }
46715
46716 }
46717
46718
46719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
46720   void * jresult ;
46721   Dali::ResourceImage *arg1 = 0 ;
46722   Dali::ResourceImage *result = 0 ;
46723
46724   arg1 = (Dali::ResourceImage *)jarg1;
46725   if (!arg1) {
46726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46727     return 0;
46728   }
46729   {
46730     try {
46731       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
46732     } catch (std::out_of_range& e) {
46733       {
46734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46735       };
46736     } catch (std::exception& e) {
46737       {
46738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46739       };
46740     } catch (Dali::DaliException e) {
46741       {
46742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46743       };
46744     } catch (...) {
46745       {
46746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46747       };
46748     }
46749   }
46750
46751   jresult = (void *)result;
46752   return jresult;
46753 }
46754
46755
46756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
46757   void * jresult ;
46758   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46759   Dali::ResourceImage *arg2 = 0 ;
46760   Dali::ResourceImage *result = 0 ;
46761
46762   arg1 = (Dali::ResourceImage *)jarg1;
46763   arg2 = (Dali::ResourceImage *)jarg2;
46764   if (!arg2) {
46765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46766     return 0;
46767   }
46768   {
46769     try {
46770       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
46771     } catch (std::out_of_range& e) {
46772       {
46773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46774       };
46775     } catch (std::exception& e) {
46776       {
46777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46778       };
46779     } catch (Dali::DaliException e) {
46780       {
46781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46782       };
46783     } catch (...) {
46784       {
46785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46786       };
46787     }
46788   }
46789
46790   jresult = (void *)result;
46791   return jresult;
46792 }
46793
46794
46795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
46796   void * jresult ;
46797   std::string *arg1 = 0 ;
46798   bool arg2 ;
46799   Dali::ResourceImage result;
46800
46801   if (!jarg1) {
46802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46803     return 0;
46804   }
46805   std::string arg1_str(jarg1);
46806   arg1 = &arg1_str;
46807   arg2 = jarg2 ? true : false;
46808   {
46809     try {
46810       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46811     } catch (std::out_of_range& e) {
46812       {
46813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46814       };
46815     } catch (std::exception& e) {
46816       {
46817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46818       };
46819     } catch (Dali::DaliException e) {
46820       {
46821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46822       };
46823     } catch (...) {
46824       {
46825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46826       };
46827     }
46828   }
46829
46830   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46831
46832   //argout typemap for const std::string&
46833
46834   return jresult;
46835 }
46836
46837
46838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
46839   void * jresult ;
46840   std::string *arg1 = 0 ;
46841   Dali::ResourceImage result;
46842
46843   if (!jarg1) {
46844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46845     return 0;
46846   }
46847   std::string arg1_str(jarg1);
46848   arg1 = &arg1_str;
46849   {
46850     try {
46851       result = Dali::ResourceImage::New((std::string const &)*arg1);
46852     } catch (std::out_of_range& e) {
46853       {
46854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46855       };
46856     } catch (std::exception& e) {
46857       {
46858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46859       };
46860     } catch (Dali::DaliException e) {
46861       {
46862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46863       };
46864     } catch (...) {
46865       {
46866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46867       };
46868     }
46869   }
46870
46871   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46872
46873   //argout typemap for const std::string&
46874
46875   return jresult;
46876 }
46877
46878
46879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
46880   void * jresult ;
46881   std::string *arg1 = 0 ;
46882   Dali::ImageDimensions arg2 ;
46883   Dali::FittingMode::Type arg3 ;
46884   Dali::SamplingMode::Type arg4 ;
46885   bool arg5 ;
46886   Dali::ImageDimensions *argp2 ;
46887   Dali::ResourceImage result;
46888
46889   if (!jarg1) {
46890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46891     return 0;
46892   }
46893   std::string arg1_str(jarg1);
46894   arg1 = &arg1_str;
46895   argp2 = (Dali::ImageDimensions *)jarg2;
46896   if (!argp2) {
46897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46898     return 0;
46899   }
46900   arg2 = *argp2;
46901   arg3 = (Dali::FittingMode::Type)jarg3;
46902   arg4 = (Dali::SamplingMode::Type)jarg4;
46903   arg5 = jarg5 ? true : false;
46904   {
46905     try {
46906       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
46907     } catch (std::out_of_range& e) {
46908       {
46909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46910       };
46911     } catch (std::exception& e) {
46912       {
46913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46914       };
46915     } catch (Dali::DaliException e) {
46916       {
46917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46918       };
46919     } catch (...) {
46920       {
46921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46922       };
46923     }
46924   }
46925
46926   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46927
46928   //argout typemap for const std::string&
46929
46930   return jresult;
46931 }
46932
46933
46934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
46935   void * jresult ;
46936   std::string *arg1 = 0 ;
46937   Dali::ImageDimensions arg2 ;
46938   Dali::FittingMode::Type arg3 ;
46939   Dali::SamplingMode::Type arg4 ;
46940   Dali::ImageDimensions *argp2 ;
46941   Dali::ResourceImage result;
46942
46943   if (!jarg1) {
46944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46945     return 0;
46946   }
46947   std::string arg1_str(jarg1);
46948   arg1 = &arg1_str;
46949   argp2 = (Dali::ImageDimensions *)jarg2;
46950   if (!argp2) {
46951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46952     return 0;
46953   }
46954   arg2 = *argp2;
46955   arg3 = (Dali::FittingMode::Type)jarg3;
46956   arg4 = (Dali::SamplingMode::Type)jarg4;
46957   {
46958     try {
46959       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
46960     } catch (std::out_of_range& e) {
46961       {
46962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46963       };
46964     } catch (std::exception& e) {
46965       {
46966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46967       };
46968     } catch (Dali::DaliException e) {
46969       {
46970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46971       };
46972     } catch (...) {
46973       {
46974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46975       };
46976     }
46977   }
46978
46979   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46980
46981   //argout typemap for const std::string&
46982
46983   return jresult;
46984 }
46985
46986
46987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
46988   void * jresult ;
46989   std::string *arg1 = 0 ;
46990   Dali::ImageDimensions arg2 ;
46991   Dali::FittingMode::Type arg3 ;
46992   Dali::ImageDimensions *argp2 ;
46993   Dali::ResourceImage result;
46994
46995   if (!jarg1) {
46996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46997     return 0;
46998   }
46999   std::string arg1_str(jarg1);
47000   arg1 = &arg1_str;
47001   argp2 = (Dali::ImageDimensions *)jarg2;
47002   if (!argp2) {
47003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
47004     return 0;
47005   }
47006   arg2 = *argp2;
47007   arg3 = (Dali::FittingMode::Type)jarg3;
47008   {
47009     try {
47010       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
47011     } catch (std::out_of_range& e) {
47012       {
47013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47014       };
47015     } catch (std::exception& e) {
47016       {
47017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47018       };
47019     } catch (Dali::DaliException e) {
47020       {
47021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47022       };
47023     } catch (...) {
47024       {
47025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47026       };
47027     }
47028   }
47029
47030   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
47031
47032   //argout typemap for const std::string&
47033
47034   return jresult;
47035 }
47036
47037
47038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
47039   void * jresult ;
47040   std::string *arg1 = 0 ;
47041   Dali::ImageDimensions arg2 ;
47042   Dali::ImageDimensions *argp2 ;
47043   Dali::ResourceImage result;
47044
47045   if (!jarg1) {
47046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47047     return 0;
47048   }
47049   std::string arg1_str(jarg1);
47050   arg1 = &arg1_str;
47051   argp2 = (Dali::ImageDimensions *)jarg2;
47052   if (!argp2) {
47053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
47054     return 0;
47055   }
47056   arg2 = *argp2;
47057   {
47058     try {
47059       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
47060     } catch (std::out_of_range& e) {
47061       {
47062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47063       };
47064     } catch (std::exception& e) {
47065       {
47066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47067       };
47068     } catch (Dali::DaliException e) {
47069       {
47070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47071       };
47072     } catch (...) {
47073       {
47074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47075       };
47076     }
47077   }
47078
47079   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
47080
47081   //argout typemap for const std::string&
47082
47083   return jresult;
47084 }
47085
47086
47087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
47088   void * jresult ;
47089   Dali::BaseHandle arg1 ;
47090   Dali::BaseHandle *argp1 ;
47091   Dali::ResourceImage result;
47092
47093   argp1 = (Dali::BaseHandle *)jarg1;
47094   if (!argp1) {
47095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47096     return 0;
47097   }
47098   arg1 = *argp1;
47099   {
47100     try {
47101       result = Dali::ResourceImage::DownCast(arg1);
47102     } catch (std::out_of_range& e) {
47103       {
47104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47105       };
47106     } catch (std::exception& e) {
47107       {
47108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47109       };
47110     } catch (Dali::DaliException e) {
47111       {
47112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47113       };
47114     } catch (...) {
47115       {
47116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47117       };
47118     }
47119   }
47120
47121   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
47122   return jresult;
47123 }
47124
47125
47126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
47127   int jresult ;
47128   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47129   Dali::LoadingState result;
47130
47131   arg1 = (Dali::ResourceImage *)jarg1;
47132   {
47133     try {
47134       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
47135     } catch (std::out_of_range& e) {
47136       {
47137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47138       };
47139     } catch (std::exception& e) {
47140       {
47141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47142       };
47143     } catch (Dali::DaliException e) {
47144       {
47145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47146       };
47147     } catch (...) {
47148       {
47149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47150       };
47151     }
47152   }
47153
47154   jresult = (int)result;
47155   return jresult;
47156 }
47157
47158
47159 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
47160   char * jresult ;
47161   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47162   std::string result;
47163
47164   arg1 = (Dali::ResourceImage *)jarg1;
47165   {
47166     try {
47167       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
47168     } catch (std::out_of_range& e) {
47169       {
47170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47171       };
47172     } catch (std::exception& e) {
47173       {
47174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47175       };
47176     } catch (Dali::DaliException e) {
47177       {
47178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47179       };
47180     } catch (...) {
47181       {
47182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47183       };
47184     }
47185   }
47186
47187   jresult = SWIG_csharp_string_callback((&result)->c_str());
47188   return jresult;
47189 }
47190
47191
47192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
47193   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47194
47195   arg1 = (Dali::ResourceImage *)jarg1;
47196   {
47197     try {
47198       (arg1)->Reload();
47199     } catch (std::out_of_range& e) {
47200       {
47201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47202       };
47203     } catch (std::exception& e) {
47204       {
47205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47206       };
47207     } catch (Dali::DaliException e) {
47208       {
47209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47210       };
47211     } catch (...) {
47212       {
47213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47214       };
47215     }
47216   }
47217
47218 }
47219
47220
47221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
47222   void * jresult ;
47223   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47224   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
47225
47226   arg1 = (Dali::ResourceImage *)jarg1;
47227   {
47228     try {
47229       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
47230     } catch (std::out_of_range& e) {
47231       {
47232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47233       };
47234     } catch (std::exception& e) {
47235       {
47236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47237       };
47238     } catch (Dali::DaliException e) {
47239       {
47240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47241       };
47242     } catch (...) {
47243       {
47244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47245       };
47246     }
47247   }
47248
47249   jresult = (void *)result;
47250   return jresult;
47251 }
47252
47253
47254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
47255   void * jresult ;
47256   Dali::FrameBufferImage *result = 0 ;
47257
47258   {
47259     try {
47260       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
47261     } catch (std::out_of_range& e) {
47262       {
47263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47264       };
47265     } catch (std::exception& e) {
47266       {
47267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47268       };
47269     } catch (Dali::DaliException e) {
47270       {
47271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47272       };
47273     } catch (...) {
47274       {
47275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47276       };
47277     }
47278   }
47279
47280   jresult = (void *)result;
47281   return jresult;
47282 }
47283
47284
47285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
47286   void * jresult ;
47287   unsigned int arg1 ;
47288   unsigned int arg2 ;
47289   Dali::Pixel::Format arg3 ;
47290   Dali::RenderBuffer::Format arg4 ;
47291   Dali::FrameBufferImage result;
47292
47293   arg1 = (unsigned int)jarg1;
47294   arg2 = (unsigned int)jarg2;
47295   arg3 = (Dali::Pixel::Format)jarg3;
47296   arg4 = (Dali::RenderBuffer::Format)jarg4;
47297   {
47298     try {
47299       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
47300     } catch (std::out_of_range& e) {
47301       {
47302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47303       };
47304     } catch (std::exception& e) {
47305       {
47306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47307       };
47308     } catch (Dali::DaliException e) {
47309       {
47310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47311       };
47312     } catch (...) {
47313       {
47314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47315       };
47316     }
47317   }
47318
47319   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47320   return jresult;
47321 }
47322
47323
47324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
47325   void * jresult ;
47326   unsigned int arg1 ;
47327   unsigned int arg2 ;
47328   Dali::Pixel::Format arg3 ;
47329   Dali::FrameBufferImage result;
47330
47331   arg1 = (unsigned int)jarg1;
47332   arg2 = (unsigned int)jarg2;
47333   arg3 = (Dali::Pixel::Format)jarg3;
47334   {
47335     try {
47336       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
47337     } catch (std::out_of_range& e) {
47338       {
47339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47340       };
47341     } catch (std::exception& e) {
47342       {
47343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47344       };
47345     } catch (Dali::DaliException e) {
47346       {
47347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47348       };
47349     } catch (...) {
47350       {
47351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47352       };
47353     }
47354   }
47355
47356   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47357   return jresult;
47358 }
47359
47360
47361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
47362   void * jresult ;
47363   unsigned int arg1 ;
47364   unsigned int arg2 ;
47365   Dali::FrameBufferImage result;
47366
47367   arg1 = (unsigned int)jarg1;
47368   arg2 = (unsigned int)jarg2;
47369   {
47370     try {
47371       result = Dali::FrameBufferImage::New(arg1,arg2);
47372     } catch (std::out_of_range& e) {
47373       {
47374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47375       };
47376     } catch (std::exception& e) {
47377       {
47378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47379       };
47380     } catch (Dali::DaliException e) {
47381       {
47382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47383       };
47384     } catch (...) {
47385       {
47386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47387       };
47388     }
47389   }
47390
47391   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47392   return jresult;
47393 }
47394
47395
47396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
47397   void * jresult ;
47398   unsigned int arg1 ;
47399   Dali::FrameBufferImage result;
47400
47401   arg1 = (unsigned int)jarg1;
47402   {
47403     try {
47404       result = Dali::FrameBufferImage::New(arg1);
47405     } catch (std::out_of_range& e) {
47406       {
47407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47408       };
47409     } catch (std::exception& e) {
47410       {
47411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47412       };
47413     } catch (Dali::DaliException e) {
47414       {
47415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47416       };
47417     } catch (...) {
47418       {
47419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47420       };
47421     }
47422   }
47423
47424   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47425   return jresult;
47426 }
47427
47428
47429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
47430   void * jresult ;
47431   Dali::FrameBufferImage result;
47432
47433   {
47434     try {
47435       result = Dali::FrameBufferImage::New();
47436     } catch (std::out_of_range& e) {
47437       {
47438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47439       };
47440     } catch (std::exception& e) {
47441       {
47442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47443       };
47444     } catch (Dali::DaliException e) {
47445       {
47446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47447       };
47448     } catch (...) {
47449       {
47450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47451       };
47452     }
47453   }
47454
47455   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47456   return jresult;
47457 }
47458
47459
47460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
47461   void * jresult ;
47462   Dali::NativeImageInterface *arg1 = 0 ;
47463   Dali::FrameBufferImage result;
47464
47465   arg1 = (Dali::NativeImageInterface *)jarg1;
47466   if (!arg1) {
47467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
47468     return 0;
47469   }
47470   {
47471     try {
47472       result = Dali::FrameBufferImage::New(*arg1);
47473     } catch (std::out_of_range& e) {
47474       {
47475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47476       };
47477     } catch (std::exception& e) {
47478       {
47479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47480       };
47481     } catch (Dali::DaliException e) {
47482       {
47483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47484       };
47485     } catch (...) {
47486       {
47487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47488       };
47489     }
47490   }
47491
47492   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47493   return jresult;
47494 }
47495
47496
47497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
47498   void * jresult ;
47499   Dali::BaseHandle arg1 ;
47500   Dali::BaseHandle *argp1 ;
47501   Dali::FrameBufferImage result;
47502
47503   argp1 = (Dali::BaseHandle *)jarg1;
47504   if (!argp1) {
47505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47506     return 0;
47507   }
47508   arg1 = *argp1;
47509   {
47510     try {
47511       result = Dali::FrameBufferImage::DownCast(arg1);
47512     } catch (std::out_of_range& e) {
47513       {
47514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47515       };
47516     } catch (std::exception& e) {
47517       {
47518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47519       };
47520     } catch (Dali::DaliException e) {
47521       {
47522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47523       };
47524     } catch (...) {
47525       {
47526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47527       };
47528     }
47529   }
47530
47531   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47532   return jresult;
47533 }
47534
47535
47536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
47537   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47538
47539   arg1 = (Dali::FrameBufferImage *)jarg1;
47540   {
47541     try {
47542       delete arg1;
47543     } catch (std::out_of_range& e) {
47544       {
47545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47546       };
47547     } catch (std::exception& e) {
47548       {
47549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47550       };
47551     } catch (Dali::DaliException e) {
47552       {
47553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47554       };
47555     } catch (...) {
47556       {
47557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47558       };
47559     }
47560   }
47561
47562 }
47563
47564
47565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
47566   void * jresult ;
47567   Dali::FrameBufferImage *arg1 = 0 ;
47568   Dali::FrameBufferImage *result = 0 ;
47569
47570   arg1 = (Dali::FrameBufferImage *)jarg1;
47571   if (!arg1) {
47572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47573     return 0;
47574   }
47575   {
47576     try {
47577       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
47578     } catch (std::out_of_range& e) {
47579       {
47580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47581       };
47582     } catch (std::exception& e) {
47583       {
47584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47585       };
47586     } catch (Dali::DaliException e) {
47587       {
47588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47589       };
47590     } catch (...) {
47591       {
47592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47593       };
47594     }
47595   }
47596
47597   jresult = (void *)result;
47598   return jresult;
47599 }
47600
47601
47602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
47603   void * jresult ;
47604   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47605   Dali::FrameBufferImage *arg2 = 0 ;
47606   Dali::FrameBufferImage *result = 0 ;
47607
47608   arg1 = (Dali::FrameBufferImage *)jarg1;
47609   arg2 = (Dali::FrameBufferImage *)jarg2;
47610   if (!arg2) {
47611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47612     return 0;
47613   }
47614   {
47615     try {
47616       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
47617     } catch (std::out_of_range& e) {
47618       {
47619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47620       };
47621     } catch (std::exception& e) {
47622       {
47623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47624       };
47625     } catch (Dali::DaliException e) {
47626       {
47627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47628       };
47629     } catch (...) {
47630       {
47631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47632       };
47633     }
47634   }
47635
47636   jresult = (void *)result;
47637   return jresult;
47638 }
47639
47640
47641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
47642   void * jresult ;
47643   Dali::NinePatchImage *result = 0 ;
47644
47645   {
47646     try {
47647       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
47648     } catch (std::out_of_range& e) {
47649       {
47650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47651       };
47652     } catch (std::exception& e) {
47653       {
47654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47655       };
47656     } catch (Dali::DaliException e) {
47657       {
47658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47659       };
47660     } catch (...) {
47661       {
47662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47663       };
47664     }
47665   }
47666
47667   jresult = (void *)result;
47668   return jresult;
47669 }
47670
47671
47672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
47673   void * jresult ;
47674   std::string *arg1 = 0 ;
47675   Dali::NinePatchImage result;
47676
47677   if (!jarg1) {
47678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47679     return 0;
47680   }
47681   std::string arg1_str(jarg1);
47682   arg1 = &arg1_str;
47683   {
47684     try {
47685       result = Dali::NinePatchImage::New((std::string const &)*arg1);
47686     } catch (std::out_of_range& e) {
47687       {
47688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47689       };
47690     } catch (std::exception& e) {
47691       {
47692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47693       };
47694     } catch (Dali::DaliException e) {
47695       {
47696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47697       };
47698     } catch (...) {
47699       {
47700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47701       };
47702     }
47703   }
47704
47705   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47706
47707   //argout typemap for const std::string&
47708
47709   return jresult;
47710 }
47711
47712
47713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
47714   void * jresult ;
47715   Dali::BaseHandle arg1 ;
47716   Dali::BaseHandle *argp1 ;
47717   Dali::NinePatchImage result;
47718
47719   argp1 = (Dali::BaseHandle *)jarg1;
47720   if (!argp1) {
47721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47722     return 0;
47723   }
47724   arg1 = *argp1;
47725   {
47726     try {
47727       result = Dali::NinePatchImage::DownCast(arg1);
47728     } catch (std::out_of_range& e) {
47729       {
47730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47731       };
47732     } catch (std::exception& e) {
47733       {
47734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47735       };
47736     } catch (Dali::DaliException e) {
47737       {
47738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47739       };
47740     } catch (...) {
47741       {
47742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47743       };
47744     }
47745   }
47746
47747   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47748   return jresult;
47749 }
47750
47751
47752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
47753   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47754
47755   arg1 = (Dali::NinePatchImage *)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_NinePatchImage__SWIG_1(void * jarg1) {
47782   void * jresult ;
47783   Dali::NinePatchImage *arg1 = 0 ;
47784   Dali::NinePatchImage *result = 0 ;
47785
47786   arg1 = (Dali::NinePatchImage *)jarg1;
47787   if (!arg1) {
47788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47789     return 0;
47790   }
47791   {
47792     try {
47793       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
47794     } catch (std::out_of_range& e) {
47795       {
47796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47797       };
47798     } catch (std::exception& e) {
47799       {
47800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47801       };
47802     } catch (Dali::DaliException e) {
47803       {
47804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47805       };
47806     } catch (...) {
47807       {
47808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47809       };
47810     }
47811   }
47812
47813   jresult = (void *)result;
47814   return jresult;
47815 }
47816
47817
47818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
47819   void * jresult ;
47820   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47821   Dali::NinePatchImage *arg2 = 0 ;
47822   Dali::NinePatchImage *result = 0 ;
47823
47824   arg1 = (Dali::NinePatchImage *)jarg1;
47825   arg2 = (Dali::NinePatchImage *)jarg2;
47826   if (!arg2) {
47827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47828     return 0;
47829   }
47830   {
47831     try {
47832       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
47833     } catch (std::out_of_range& e) {
47834       {
47835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47836       };
47837     } catch (std::exception& e) {
47838       {
47839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47840       };
47841     } catch (Dali::DaliException e) {
47842       {
47843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47844       };
47845     } catch (...) {
47846       {
47847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47848       };
47849     }
47850   }
47851
47852   jresult = (void *)result;
47853   return jresult;
47854 }
47855
47856
47857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
47858   void * jresult ;
47859   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47860   Dali::Vector4 result;
47861
47862   arg1 = (Dali::NinePatchImage *)jarg1;
47863   {
47864     try {
47865       result = (arg1)->GetStretchBorders();
47866     } catch (std::out_of_range& e) {
47867       {
47868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47869       };
47870     } catch (std::exception& e) {
47871       {
47872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47873       };
47874     } catch (Dali::DaliException e) {
47875       {
47876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47877       };
47878     } catch (...) {
47879       {
47880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47881       };
47882     }
47883   }
47884
47885   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
47886   return jresult;
47887 }
47888
47889
47890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
47891   void * jresult ;
47892   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47893   Dali::NinePatchImage::StretchRanges *result = 0 ;
47894
47895   arg1 = (Dali::NinePatchImage *)jarg1;
47896   {
47897     try {
47898       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
47899     } catch (std::out_of_range& e) {
47900       {
47901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47902       };
47903     } catch (std::exception& e) {
47904       {
47905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47906       };
47907     } catch (Dali::DaliException e) {
47908       {
47909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47910       };
47911     } catch (...) {
47912       {
47913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47914       };
47915     }
47916   }
47917
47918   jresult = (void *)result;
47919   return jresult;
47920 }
47921
47922
47923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
47924   void * jresult ;
47925   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47926   Dali::NinePatchImage::StretchRanges *result = 0 ;
47927
47928   arg1 = (Dali::NinePatchImage *)jarg1;
47929   {
47930     try {
47931       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
47932     } catch (std::out_of_range& e) {
47933       {
47934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47935       };
47936     } catch (std::exception& e) {
47937       {
47938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47939       };
47940     } catch (Dali::DaliException e) {
47941       {
47942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47943       };
47944     } catch (...) {
47945       {
47946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47947       };
47948     }
47949   }
47950
47951   jresult = (void *)result;
47952   return jresult;
47953 }
47954
47955
47956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
47957   void * jresult ;
47958   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47959   Dali::Rect< int > result;
47960
47961   arg1 = (Dali::NinePatchImage *)jarg1;
47962   {
47963     try {
47964       result = (arg1)->GetChildRectangle();
47965     } catch (std::out_of_range& e) {
47966       {
47967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47968       };
47969     } catch (std::exception& e) {
47970       {
47971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47972       };
47973     } catch (Dali::DaliException e) {
47974       {
47975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47976       };
47977     } catch (...) {
47978       {
47979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47980       };
47981     }
47982   }
47983
47984   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
47985   return jresult;
47986 }
47987
47988
47989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
47990   void * jresult ;
47991   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47992   Dali::BufferImage result;
47993
47994   arg1 = (Dali::NinePatchImage *)jarg1;
47995   {
47996     try {
47997       result = (arg1)->CreateCroppedBufferImage();
47998     } catch (std::out_of_range& e) {
47999       {
48000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48001       };
48002     } catch (std::exception& e) {
48003       {
48004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48005       };
48006     } catch (Dali::DaliException e) {
48007       {
48008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48009       };
48010     } catch (...) {
48011       {
48012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48013       };
48014     }
48015   }
48016
48017   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
48018   return jresult;
48019 }
48020
48021
48022 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
48023   unsigned int jresult ;
48024   std::string *arg1 = 0 ;
48025   bool result;
48026
48027   if (!jarg1) {
48028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48029     return 0;
48030   }
48031   std::string arg1_str(jarg1);
48032   arg1 = &arg1_str;
48033   {
48034     try {
48035       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
48036     } catch (std::out_of_range& e) {
48037       {
48038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48039       };
48040     } catch (std::exception& e) {
48041       {
48042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48043       };
48044     } catch (Dali::DaliException e) {
48045       {
48046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48047       };
48048     } catch (...) {
48049       {
48050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48051       };
48052     }
48053   }
48054
48055   jresult = result;
48056
48057   //argout typemap for const std::string&
48058
48059   return jresult;
48060 }
48061
48062
48063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
48064   int jresult ;
48065   int result;
48066
48067   result = (int)Dali::CameraActor::Property::TYPE;
48068   jresult = (int)result;
48069   return jresult;
48070 }
48071
48072
48073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
48074   int jresult ;
48075   int result;
48076
48077   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
48078   jresult = (int)result;
48079   return jresult;
48080 }
48081
48082
48083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
48084   int jresult ;
48085   int result;
48086
48087   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
48088   jresult = (int)result;
48089   return jresult;
48090 }
48091
48092
48093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
48094   int jresult ;
48095   int result;
48096
48097   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
48098   jresult = (int)result;
48099   return jresult;
48100 }
48101
48102
48103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
48104   int jresult ;
48105   int result;
48106
48107   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
48108   jresult = (int)result;
48109   return jresult;
48110 }
48111
48112
48113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
48114   int jresult ;
48115   int result;
48116
48117   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
48118   jresult = (int)result;
48119   return jresult;
48120 }
48121
48122
48123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
48124   int jresult ;
48125   int result;
48126
48127   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
48128   jresult = (int)result;
48129   return jresult;
48130 }
48131
48132
48133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
48134   int jresult ;
48135   int result;
48136
48137   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
48138   jresult = (int)result;
48139   return jresult;
48140 }
48141
48142
48143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
48144   int jresult ;
48145   int result;
48146
48147   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
48148   jresult = (int)result;
48149   return jresult;
48150 }
48151
48152
48153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
48154   int jresult ;
48155   int result;
48156
48157   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
48158   jresult = (int)result;
48159   return jresult;
48160 }
48161
48162
48163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
48164   int jresult ;
48165   int result;
48166
48167   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
48168   jresult = (int)result;
48169   return jresult;
48170 }
48171
48172
48173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
48174   int jresult ;
48175   int result;
48176
48177   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
48178   jresult = (int)result;
48179   return jresult;
48180 }
48181
48182
48183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
48184   int jresult ;
48185   int result;
48186
48187   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
48188   jresult = (int)result;
48189   return jresult;
48190 }
48191
48192
48193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
48194   int jresult ;
48195   int result;
48196
48197   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
48198   jresult = (int)result;
48199   return jresult;
48200 }
48201
48202
48203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
48204   void * jresult ;
48205   Dali::CameraActor::Property *result = 0 ;
48206
48207   {
48208     try {
48209       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
48210     } catch (std::out_of_range& e) {
48211       {
48212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48213       };
48214     } catch (std::exception& e) {
48215       {
48216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48217       };
48218     } catch (Dali::DaliException e) {
48219       {
48220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48221       };
48222     } catch (...) {
48223       {
48224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48225       };
48226     }
48227   }
48228
48229   jresult = (void *)result;
48230   return jresult;
48231 }
48232
48233
48234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
48235   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
48236
48237   arg1 = (Dali::CameraActor::Property *)jarg1;
48238   {
48239     try {
48240       delete arg1;
48241     } catch (std::out_of_range& e) {
48242       {
48243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48244       };
48245     } catch (std::exception& e) {
48246       {
48247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48248       };
48249     } catch (Dali::DaliException e) {
48250       {
48251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48252       };
48253     } catch (...) {
48254       {
48255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48256       };
48257     }
48258   }
48259
48260 }
48261
48262
48263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
48264   void * jresult ;
48265   Dali::CameraActor *result = 0 ;
48266
48267   {
48268     try {
48269       result = (Dali::CameraActor *)new Dali::CameraActor();
48270     } catch (std::out_of_range& e) {
48271       {
48272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48273       };
48274     } catch (std::exception& e) {
48275       {
48276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48277       };
48278     } catch (Dali::DaliException e) {
48279       {
48280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48281       };
48282     } catch (...) {
48283       {
48284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48285       };
48286     }
48287   }
48288
48289   jresult = (void *)result;
48290   return jresult;
48291 }
48292
48293
48294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
48295   void * jresult ;
48296   Dali::CameraActor result;
48297
48298   {
48299     try {
48300       result = Dali::CameraActor::New();
48301     } catch (std::out_of_range& e) {
48302       {
48303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48304       };
48305     } catch (std::exception& e) {
48306       {
48307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48308       };
48309     } catch (Dali::DaliException e) {
48310       {
48311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48312       };
48313     } catch (...) {
48314       {
48315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48316       };
48317     }
48318   }
48319
48320   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48321   return jresult;
48322 }
48323
48324
48325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
48326   void * jresult ;
48327   Dali::Size *arg1 = 0 ;
48328   Dali::CameraActor result;
48329
48330   arg1 = (Dali::Size *)jarg1;
48331   if (!arg1) {
48332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48333     return 0;
48334   }
48335   {
48336     try {
48337       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
48338     } catch (std::out_of_range& e) {
48339       {
48340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48341       };
48342     } catch (std::exception& e) {
48343       {
48344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48345       };
48346     } catch (Dali::DaliException e) {
48347       {
48348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48349       };
48350     } catch (...) {
48351       {
48352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48353       };
48354     }
48355   }
48356
48357   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48358   return jresult;
48359 }
48360
48361
48362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
48363   void * jresult ;
48364   Dali::BaseHandle arg1 ;
48365   Dali::BaseHandle *argp1 ;
48366   Dali::CameraActor result;
48367
48368   argp1 = (Dali::BaseHandle *)jarg1;
48369   if (!argp1) {
48370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48371     return 0;
48372   }
48373   arg1 = *argp1;
48374   {
48375     try {
48376       result = Dali::CameraActor::DownCast(arg1);
48377     } catch (std::out_of_range& e) {
48378       {
48379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48380       };
48381     } catch (std::exception& e) {
48382       {
48383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48384       };
48385     } catch (Dali::DaliException e) {
48386       {
48387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48388       };
48389     } catch (...) {
48390       {
48391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48392       };
48393     }
48394   }
48395
48396   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48397   return jresult;
48398 }
48399
48400
48401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
48402   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48403
48404   arg1 = (Dali::CameraActor *)jarg1;
48405   {
48406     try {
48407       delete arg1;
48408     } catch (std::out_of_range& e) {
48409       {
48410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48411       };
48412     } catch (std::exception& e) {
48413       {
48414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48415       };
48416     } catch (Dali::DaliException e) {
48417       {
48418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48419       };
48420     } catch (...) {
48421       {
48422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48423       };
48424     }
48425   }
48426
48427 }
48428
48429
48430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
48431   void * jresult ;
48432   Dali::CameraActor *arg1 = 0 ;
48433   Dali::CameraActor *result = 0 ;
48434
48435   arg1 = (Dali::CameraActor *)jarg1;
48436   if (!arg1) {
48437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48438     return 0;
48439   }
48440   {
48441     try {
48442       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
48443     } catch (std::out_of_range& e) {
48444       {
48445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48446       };
48447     } catch (std::exception& e) {
48448       {
48449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48450       };
48451     } catch (Dali::DaliException e) {
48452       {
48453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48454       };
48455     } catch (...) {
48456       {
48457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48458       };
48459     }
48460   }
48461
48462   jresult = (void *)result;
48463   return jresult;
48464 }
48465
48466
48467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
48468   void * jresult ;
48469   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48470   Dali::CameraActor *arg2 = 0 ;
48471   Dali::CameraActor *result = 0 ;
48472
48473   arg1 = (Dali::CameraActor *)jarg1;
48474   arg2 = (Dali::CameraActor *)jarg2;
48475   if (!arg2) {
48476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48477     return 0;
48478   }
48479   {
48480     try {
48481       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
48482     } catch (std::out_of_range& e) {
48483       {
48484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48485       };
48486     } catch (std::exception& e) {
48487       {
48488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48489       };
48490     } catch (Dali::DaliException e) {
48491       {
48492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48493       };
48494     } catch (...) {
48495       {
48496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48497       };
48498     }
48499   }
48500
48501   jresult = (void *)result;
48502   return jresult;
48503 }
48504
48505
48506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
48507   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48508   Dali::Camera::Type arg2 ;
48509
48510   arg1 = (Dali::CameraActor *)jarg1;
48511   arg2 = (Dali::Camera::Type)jarg2;
48512   {
48513     try {
48514       (arg1)->SetType(arg2);
48515     } catch (std::out_of_range& e) {
48516       {
48517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48518       };
48519     } catch (std::exception& e) {
48520       {
48521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48522       };
48523     } catch (Dali::DaliException e) {
48524       {
48525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48526       };
48527     } catch (...) {
48528       {
48529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48530       };
48531     }
48532   }
48533
48534 }
48535
48536
48537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
48538   int jresult ;
48539   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48540   Dali::Camera::Type result;
48541
48542   arg1 = (Dali::CameraActor *)jarg1;
48543   {
48544     try {
48545       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
48546     } catch (std::out_of_range& e) {
48547       {
48548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48549       };
48550     } catch (std::exception& e) {
48551       {
48552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48553       };
48554     } catch (Dali::DaliException e) {
48555       {
48556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48557       };
48558     } catch (...) {
48559       {
48560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48561       };
48562     }
48563   }
48564
48565   jresult = (int)result;
48566   return jresult;
48567 }
48568
48569
48570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
48571   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48572   Dali::Camera::ProjectionMode arg2 ;
48573
48574   arg1 = (Dali::CameraActor *)jarg1;
48575   arg2 = (Dali::Camera::ProjectionMode)jarg2;
48576   {
48577     try {
48578       (arg1)->SetProjectionMode(arg2);
48579     } catch (std::out_of_range& e) {
48580       {
48581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48582       };
48583     } catch (std::exception& e) {
48584       {
48585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48586       };
48587     } catch (Dali::DaliException e) {
48588       {
48589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48590       };
48591     } catch (...) {
48592       {
48593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48594       };
48595     }
48596   }
48597
48598 }
48599
48600
48601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
48602   int jresult ;
48603   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48604   Dali::Camera::ProjectionMode result;
48605
48606   arg1 = (Dali::CameraActor *)jarg1;
48607   {
48608     try {
48609       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
48610     } catch (std::out_of_range& e) {
48611       {
48612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48613       };
48614     } catch (std::exception& e) {
48615       {
48616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48617       };
48618     } catch (Dali::DaliException e) {
48619       {
48620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48621       };
48622     } catch (...) {
48623       {
48624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48625       };
48626     }
48627   }
48628
48629   jresult = (int)result;
48630   return jresult;
48631 }
48632
48633
48634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
48635   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48636   float arg2 ;
48637
48638   arg1 = (Dali::CameraActor *)jarg1;
48639   arg2 = (float)jarg2;
48640   {
48641     try {
48642       (arg1)->SetFieldOfView(arg2);
48643     } catch (std::out_of_range& e) {
48644       {
48645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48646       };
48647     } catch (std::exception& e) {
48648       {
48649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48650       };
48651     } catch (Dali::DaliException e) {
48652       {
48653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48654       };
48655     } catch (...) {
48656       {
48657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48658       };
48659     }
48660   }
48661
48662 }
48663
48664
48665 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
48666   float jresult ;
48667   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48668   float result;
48669
48670   arg1 = (Dali::CameraActor *)jarg1;
48671   {
48672     try {
48673       result = (float)(arg1)->GetFieldOfView();
48674     } catch (std::out_of_range& e) {
48675       {
48676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48677       };
48678     } catch (std::exception& e) {
48679       {
48680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48681       };
48682     } catch (Dali::DaliException e) {
48683       {
48684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48685       };
48686     } catch (...) {
48687       {
48688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48689       };
48690     }
48691   }
48692
48693   jresult = result;
48694   return jresult;
48695 }
48696
48697
48698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
48699   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48700   float arg2 ;
48701
48702   arg1 = (Dali::CameraActor *)jarg1;
48703   arg2 = (float)jarg2;
48704   {
48705     try {
48706       (arg1)->SetAspectRatio(arg2);
48707     } catch (std::out_of_range& e) {
48708       {
48709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48710       };
48711     } catch (std::exception& e) {
48712       {
48713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48714       };
48715     } catch (Dali::DaliException e) {
48716       {
48717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48718       };
48719     } catch (...) {
48720       {
48721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48722       };
48723     }
48724   }
48725
48726 }
48727
48728
48729 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
48730   float jresult ;
48731   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48732   float result;
48733
48734   arg1 = (Dali::CameraActor *)jarg1;
48735   {
48736     try {
48737       result = (float)(arg1)->GetAspectRatio();
48738     } catch (std::out_of_range& e) {
48739       {
48740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48741       };
48742     } catch (std::exception& e) {
48743       {
48744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48745       };
48746     } catch (Dali::DaliException e) {
48747       {
48748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48749       };
48750     } catch (...) {
48751       {
48752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48753       };
48754     }
48755   }
48756
48757   jresult = result;
48758   return jresult;
48759 }
48760
48761
48762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
48763   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48764   float arg2 ;
48765
48766   arg1 = (Dali::CameraActor *)jarg1;
48767   arg2 = (float)jarg2;
48768   {
48769     try {
48770       (arg1)->SetNearClippingPlane(arg2);
48771     } catch (std::out_of_range& e) {
48772       {
48773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48774       };
48775     } catch (std::exception& e) {
48776       {
48777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48778       };
48779     } catch (Dali::DaliException e) {
48780       {
48781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48782       };
48783     } catch (...) {
48784       {
48785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48786       };
48787     }
48788   }
48789
48790 }
48791
48792
48793 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
48794   float jresult ;
48795   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48796   float result;
48797
48798   arg1 = (Dali::CameraActor *)jarg1;
48799   {
48800     try {
48801       result = (float)(arg1)->GetNearClippingPlane();
48802     } catch (std::out_of_range& e) {
48803       {
48804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48805       };
48806     } catch (std::exception& e) {
48807       {
48808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48809       };
48810     } catch (Dali::DaliException e) {
48811       {
48812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48813       };
48814     } catch (...) {
48815       {
48816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48817       };
48818     }
48819   }
48820
48821   jresult = result;
48822   return jresult;
48823 }
48824
48825
48826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
48827   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48828   float arg2 ;
48829
48830   arg1 = (Dali::CameraActor *)jarg1;
48831   arg2 = (float)jarg2;
48832   {
48833     try {
48834       (arg1)->SetFarClippingPlane(arg2);
48835     } catch (std::out_of_range& e) {
48836       {
48837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48838       };
48839     } catch (std::exception& e) {
48840       {
48841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48842       };
48843     } catch (Dali::DaliException e) {
48844       {
48845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48846       };
48847     } catch (...) {
48848       {
48849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48850       };
48851     }
48852   }
48853
48854 }
48855
48856
48857 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
48858   float jresult ;
48859   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48860   float result;
48861
48862   arg1 = (Dali::CameraActor *)jarg1;
48863   {
48864     try {
48865       result = (float)(arg1)->GetFarClippingPlane();
48866     } catch (std::out_of_range& e) {
48867       {
48868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48869       };
48870     } catch (std::exception& e) {
48871       {
48872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48873       };
48874     } catch (Dali::DaliException e) {
48875       {
48876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48877       };
48878     } catch (...) {
48879       {
48880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48881       };
48882     }
48883   }
48884
48885   jresult = result;
48886   return jresult;
48887 }
48888
48889
48890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
48891   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48892   Dali::Vector3 *arg2 = 0 ;
48893
48894   arg1 = (Dali::CameraActor *)jarg1;
48895   arg2 = (Dali::Vector3 *)jarg2;
48896   if (!arg2) {
48897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
48898     return ;
48899   }
48900   {
48901     try {
48902       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
48903     } catch (std::out_of_range& e) {
48904       {
48905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48906       };
48907     } catch (std::exception& e) {
48908       {
48909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48910       };
48911     } catch (Dali::DaliException e) {
48912       {
48913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48914       };
48915     } catch (...) {
48916       {
48917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48918       };
48919     }
48920   }
48921
48922 }
48923
48924
48925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
48926   void * jresult ;
48927   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48928   Dali::Vector3 result;
48929
48930   arg1 = (Dali::CameraActor *)jarg1;
48931   {
48932     try {
48933       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
48934     } catch (std::out_of_range& e) {
48935       {
48936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48937       };
48938     } catch (std::exception& e) {
48939       {
48940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48941       };
48942     } catch (Dali::DaliException e) {
48943       {
48944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48945       };
48946     } catch (...) {
48947       {
48948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48949       };
48950     }
48951   }
48952
48953   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
48954   return jresult;
48955 }
48956
48957
48958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
48959   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48960   bool arg2 ;
48961
48962   arg1 = (Dali::CameraActor *)jarg1;
48963   arg2 = jarg2 ? true : false;
48964   {
48965     try {
48966       (arg1)->SetInvertYAxis(arg2);
48967     } catch (std::out_of_range& e) {
48968       {
48969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48970       };
48971     } catch (std::exception& e) {
48972       {
48973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48974       };
48975     } catch (Dali::DaliException e) {
48976       {
48977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48978       };
48979     } catch (...) {
48980       {
48981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48982       };
48983     }
48984   }
48985
48986 }
48987
48988
48989 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
48990   unsigned int jresult ;
48991   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48992   bool result;
48993
48994   arg1 = (Dali::CameraActor *)jarg1;
48995   {
48996     try {
48997       result = (bool)(arg1)->GetInvertYAxis();
48998     } catch (std::out_of_range& e) {
48999       {
49000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49001       };
49002     } catch (std::exception& e) {
49003       {
49004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49005       };
49006     } catch (Dali::DaliException e) {
49007       {
49008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49009       };
49010     } catch (...) {
49011       {
49012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49013       };
49014     }
49015   }
49016
49017   jresult = result;
49018   return jresult;
49019 }
49020
49021
49022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
49023   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
49024   Dali::Size *arg2 = 0 ;
49025
49026   arg1 = (Dali::CameraActor *)jarg1;
49027   arg2 = (Dali::Size *)jarg2;
49028   if (!arg2) {
49029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
49030     return ;
49031   }
49032   {
49033     try {
49034       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
49035     } catch (std::out_of_range& e) {
49036       {
49037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49038       };
49039     } catch (std::exception& e) {
49040       {
49041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49042       };
49043     } catch (Dali::DaliException e) {
49044       {
49045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49046       };
49047     } catch (...) {
49048       {
49049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49050       };
49051     }
49052   }
49053
49054 }
49055
49056
49057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
49058   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
49059   Dali::Size *arg2 = 0 ;
49060
49061   arg1 = (Dali::CameraActor *)jarg1;
49062   arg2 = (Dali::Size *)jarg2;
49063   if (!arg2) {
49064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
49065     return ;
49066   }
49067   {
49068     try {
49069       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
49070     } catch (std::out_of_range& e) {
49071       {
49072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49073       };
49074     } catch (std::exception& e) {
49075       {
49076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49077       };
49078     } catch (Dali::DaliException e) {
49079       {
49080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49081       };
49082     } catch (...) {
49083       {
49084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49085       };
49086     }
49087   }
49088
49089 }
49090
49091
49092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
49093   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
49094   float arg2 ;
49095   float arg3 ;
49096   float arg4 ;
49097   float arg5 ;
49098   float arg6 ;
49099   float arg7 ;
49100
49101   arg1 = (Dali::CameraActor *)jarg1;
49102   arg2 = (float)jarg2;
49103   arg3 = (float)jarg3;
49104   arg4 = (float)jarg4;
49105   arg5 = (float)jarg5;
49106   arg6 = (float)jarg6;
49107   arg7 = (float)jarg7;
49108   {
49109     try {
49110       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
49111     } catch (std::out_of_range& e) {
49112       {
49113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49114       };
49115     } catch (std::exception& e) {
49116       {
49117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49118       };
49119     } catch (Dali::DaliException e) {
49120       {
49121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49122       };
49123     } catch (...) {
49124       {
49125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49126       };
49127     }
49128   }
49129
49130 }
49131
49132
49133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
49134   void * jresult ;
49135   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49136
49137   {
49138     try {
49139       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
49140     } catch (std::out_of_range& e) {
49141       {
49142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49143       };
49144     } catch (std::exception& e) {
49145       {
49146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49147       };
49148     } catch (Dali::DaliException e) {
49149       {
49150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49151       };
49152     } catch (...) {
49153       {
49154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49155       };
49156     }
49157   }
49158
49159   jresult = (void *)result;
49160   return jresult;
49161 }
49162
49163
49164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
49165   void * jresult ;
49166   std::string arg1 ;
49167   Dali::Property::Value arg2 ;
49168   Dali::Property::Value *argp2 ;
49169   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49170
49171   if (!jarg1) {
49172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49173     return 0;
49174   }
49175   (&arg1)->assign(jarg1);
49176   argp2 = (Dali::Property::Value *)jarg2;
49177   if (!argp2) {
49178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
49179     return 0;
49180   }
49181   arg2 = *argp2;
49182   {
49183     try {
49184       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
49185     } catch (std::out_of_range& e) {
49186       {
49187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49188       };
49189     } catch (std::exception& e) {
49190       {
49191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49192       };
49193     } catch (Dali::DaliException e) {
49194       {
49195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49196       };
49197     } catch (...) {
49198       {
49199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49200       };
49201     }
49202   }
49203
49204   jresult = (void *)result;
49205   return jresult;
49206 }
49207
49208
49209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
49210   void * jresult ;
49211   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
49212   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49213
49214   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49215   if (!arg1) {
49216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
49217     return 0;
49218   }
49219   {
49220     try {
49221       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);
49222     } catch (std::out_of_range& e) {
49223       {
49224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49225       };
49226     } catch (std::exception& e) {
49227       {
49228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49229       };
49230     } catch (Dali::DaliException e) {
49231       {
49232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49233       };
49234     } catch (...) {
49235       {
49236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49237       };
49238     }
49239   }
49240
49241   jresult = (void *)result;
49242   return jresult;
49243 }
49244
49245
49246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
49247   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49248   std::string *arg2 = 0 ;
49249
49250   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49251   if (!jarg2) {
49252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49253     return ;
49254   }
49255   std::string arg2_str(jarg2);
49256   arg2 = &arg2_str;
49257   if (arg1) (arg1)->first = *arg2;
49258
49259   //argout typemap for const std::string&
49260
49261 }
49262
49263
49264 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
49265   char * jresult ;
49266   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49267   std::string *result = 0 ;
49268
49269   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49270   result = (std::string *) & ((arg1)->first);
49271   jresult = SWIG_csharp_string_callback(result->c_str());
49272   return jresult;
49273 }
49274
49275
49276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
49277   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49278   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
49279
49280   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49281   arg2 = (Dali::Property::Value *)jarg2;
49282   if (arg1) (arg1)->second = *arg2;
49283 }
49284
49285
49286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
49287   void * jresult ;
49288   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49289   Dali::Property::Value *result = 0 ;
49290
49291   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49292   result = (Dali::Property::Value *)& ((arg1)->second);
49293   jresult = (void *)result;
49294   return jresult;
49295 }
49296
49297
49298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
49299   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49300
49301   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49302   {
49303     try {
49304       delete arg1;
49305     } catch (std::out_of_range& e) {
49306       {
49307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49308       };
49309     } catch (std::exception& e) {
49310       {
49311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49312       };
49313     } catch (Dali::DaliException e) {
49314       {
49315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49316       };
49317     } catch (...) {
49318       {
49319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49320       };
49321     }
49322   }
49323
49324 }
49325
49326
49327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
49328   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49329
49330   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49331   {
49332     try {
49333       (arg1)->clear();
49334     } catch (std::out_of_range& e) {
49335       {
49336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49337       };
49338     } catch (std::exception& e) {
49339       {
49340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49341       };
49342     } catch (Dali::DaliException e) {
49343       {
49344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49345       };
49346     } catch (...) {
49347       {
49348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49349       };
49350     }
49351   }
49352
49353 }
49354
49355
49356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
49357   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49358   Dali::TouchPoint *arg2 = 0 ;
49359
49360   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49361   arg2 = (Dali::TouchPoint *)jarg2;
49362   if (!arg2) {
49363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49364     return ;
49365   }
49366   {
49367     try {
49368       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
49369     } catch (std::out_of_range& e) {
49370       {
49371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49372       };
49373     } catch (std::exception& e) {
49374       {
49375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49376       };
49377     } catch (Dali::DaliException e) {
49378       {
49379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49380       };
49381     } catch (...) {
49382       {
49383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49384       };
49385     }
49386   }
49387
49388 }
49389
49390
49391 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
49392   unsigned long jresult ;
49393   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49394   std::vector< Dali::TouchPoint >::size_type result;
49395
49396   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49397   {
49398     try {
49399       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
49400     } catch (std::out_of_range& e) {
49401       {
49402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49403       };
49404     } catch (std::exception& e) {
49405       {
49406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49407       };
49408     } catch (Dali::DaliException e) {
49409       {
49410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49411       };
49412     } catch (...) {
49413       {
49414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49415       };
49416     }
49417   }
49418
49419   jresult = (unsigned long)result;
49420   return jresult;
49421 }
49422
49423
49424 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
49425   unsigned long jresult ;
49426   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49427   std::vector< Dali::TouchPoint >::size_type result;
49428
49429   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49430   {
49431     try {
49432       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
49433     } catch (std::out_of_range& e) {
49434       {
49435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49436       };
49437     } catch (std::exception& e) {
49438       {
49439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49440       };
49441     } catch (Dali::DaliException e) {
49442       {
49443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49444       };
49445     } catch (...) {
49446       {
49447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49448       };
49449     }
49450   }
49451
49452   jresult = (unsigned long)result;
49453   return jresult;
49454 }
49455
49456
49457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
49458   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49459   std::vector< Dali::TouchPoint >::size_type arg2 ;
49460
49461   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49462   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
49463   {
49464     try {
49465       (arg1)->reserve(arg2);
49466     } catch (std::out_of_range& e) {
49467       {
49468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49469       };
49470     } catch (std::exception& e) {
49471       {
49472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49473       };
49474     } catch (Dali::DaliException e) {
49475       {
49476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49477       };
49478     } catch (...) {
49479       {
49480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49481       };
49482     }
49483   }
49484
49485 }
49486
49487
49488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
49489   void * jresult ;
49490   std::vector< Dali::TouchPoint > *result = 0 ;
49491
49492   {
49493     try {
49494       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
49495     } catch (std::out_of_range& e) {
49496       {
49497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49498       };
49499     } catch (std::exception& e) {
49500       {
49501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49502       };
49503     } catch (Dali::DaliException e) {
49504       {
49505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49506       };
49507     } catch (...) {
49508       {
49509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49510       };
49511     }
49512   }
49513
49514   jresult = (void *)result;
49515   return jresult;
49516 }
49517
49518
49519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
49520   void * jresult ;
49521   std::vector< Dali::TouchPoint > *arg1 = 0 ;
49522   std::vector< Dali::TouchPoint > *result = 0 ;
49523
49524   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49525   if (!arg1) {
49526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49527     return 0;
49528   }
49529   {
49530     try {
49531       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
49532     } catch (std::out_of_range& e) {
49533       {
49534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49535       };
49536     } catch (std::exception& e) {
49537       {
49538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49539       };
49540     } catch (Dali::DaliException e) {
49541       {
49542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49543       };
49544     } catch (...) {
49545       {
49546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49547       };
49548     }
49549   }
49550
49551   jresult = (void *)result;
49552   return jresult;
49553 }
49554
49555
49556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
49557   void * jresult ;
49558   int arg1 ;
49559   std::vector< Dali::TouchPoint > *result = 0 ;
49560
49561   arg1 = (int)jarg1;
49562   {
49563     try {
49564       try {
49565         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
49566       }
49567       catch(std::out_of_range &_e) {
49568         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49569         return 0;
49570       }
49571
49572     } catch (std::out_of_range& e) {
49573       {
49574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49575       };
49576     } catch (std::exception& e) {
49577       {
49578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49579       };
49580     } catch (Dali::DaliException e) {
49581       {
49582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49583       };
49584     } catch (...) {
49585       {
49586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49587       };
49588     }
49589   }
49590
49591   jresult = (void *)result;
49592   return jresult;
49593 }
49594
49595
49596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
49597   void * jresult ;
49598   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49599   int arg2 ;
49600   SwigValueWrapper< Dali::TouchPoint > result;
49601
49602   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49603   arg2 = (int)jarg2;
49604   {
49605     try {
49606       try {
49607         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
49608       }
49609       catch(std::out_of_range &_e) {
49610         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49611         return 0;
49612       }
49613
49614     } catch (std::out_of_range& e) {
49615       {
49616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49617       };
49618     } catch (std::exception& e) {
49619       {
49620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49621       };
49622     } catch (Dali::DaliException e) {
49623       {
49624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49625       };
49626     } catch (...) {
49627       {
49628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49629       };
49630     }
49631   }
49632
49633   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
49634   return jresult;
49635 }
49636
49637
49638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
49639   void * jresult ;
49640   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49641   int arg2 ;
49642   Dali::TouchPoint *result = 0 ;
49643
49644   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49645   arg2 = (int)jarg2;
49646   {
49647     try {
49648       try {
49649         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
49650       }
49651       catch(std::out_of_range &_e) {
49652         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49653         return 0;
49654       }
49655
49656     } catch (std::out_of_range& e) {
49657       {
49658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49659       };
49660     } catch (std::exception& e) {
49661       {
49662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49663       };
49664     } catch (Dali::DaliException e) {
49665       {
49666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49667       };
49668     } catch (...) {
49669       {
49670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49671       };
49672     }
49673   }
49674
49675   jresult = (void *)result;
49676   return jresult;
49677 }
49678
49679
49680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
49681   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49682   int arg2 ;
49683   Dali::TouchPoint *arg3 = 0 ;
49684
49685   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49686   arg2 = (int)jarg2;
49687   arg3 = (Dali::TouchPoint *)jarg3;
49688   if (!arg3) {
49689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49690     return ;
49691   }
49692   {
49693     try {
49694       try {
49695         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49696       }
49697       catch(std::out_of_range &_e) {
49698         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49699         return ;
49700       }
49701
49702     } catch (std::out_of_range& e) {
49703       {
49704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49705       };
49706     } catch (std::exception& e) {
49707       {
49708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49709       };
49710     } catch (Dali::DaliException e) {
49711       {
49712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49713       };
49714     } catch (...) {
49715       {
49716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49717       };
49718     }
49719   }
49720
49721 }
49722
49723
49724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
49725   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49726   std::vector< Dali::TouchPoint > *arg2 = 0 ;
49727
49728   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49729   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
49730   if (!arg2) {
49731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49732     return ;
49733   }
49734   {
49735     try {
49736       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
49737     } catch (std::out_of_range& e) {
49738       {
49739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49740       };
49741     } catch (std::exception& e) {
49742       {
49743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49744       };
49745     } catch (Dali::DaliException e) {
49746       {
49747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49748       };
49749     } catch (...) {
49750       {
49751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49752       };
49753     }
49754   }
49755
49756 }
49757
49758
49759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
49760   void * jresult ;
49761   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49762   int arg2 ;
49763   int arg3 ;
49764   std::vector< Dali::TouchPoint > *result = 0 ;
49765
49766   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49767   arg2 = (int)jarg2;
49768   arg3 = (int)jarg3;
49769   {
49770     try {
49771       try {
49772         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
49773       }
49774       catch(std::out_of_range &_e) {
49775         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49776         return 0;
49777       }
49778       catch(std::invalid_argument &_e) {
49779         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49780         return 0;
49781       }
49782
49783     } catch (std::out_of_range& e) {
49784       {
49785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49786       };
49787     } catch (std::exception& e) {
49788       {
49789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49790       };
49791     } catch (Dali::DaliException e) {
49792       {
49793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49794       };
49795     } catch (...) {
49796       {
49797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49798       };
49799     }
49800   }
49801
49802   jresult = (void *)result;
49803   return jresult;
49804 }
49805
49806
49807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
49808   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49809   int arg2 ;
49810   Dali::TouchPoint *arg3 = 0 ;
49811
49812   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49813   arg2 = (int)jarg2;
49814   arg3 = (Dali::TouchPoint *)jarg3;
49815   if (!arg3) {
49816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49817     return ;
49818   }
49819   {
49820     try {
49821       try {
49822         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49823       }
49824       catch(std::out_of_range &_e) {
49825         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49826         return ;
49827       }
49828
49829     } catch (std::out_of_range& e) {
49830       {
49831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49832       };
49833     } catch (std::exception& e) {
49834       {
49835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49836       };
49837     } catch (Dali::DaliException e) {
49838       {
49839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49840       };
49841     } catch (...) {
49842       {
49843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49844       };
49845     }
49846   }
49847
49848 }
49849
49850
49851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
49852   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49853   int arg2 ;
49854   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49855
49856   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49857   arg2 = (int)jarg2;
49858   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49859   if (!arg3) {
49860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49861     return ;
49862   }
49863   {
49864     try {
49865       try {
49866         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49867       }
49868       catch(std::out_of_range &_e) {
49869         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49870         return ;
49871       }
49872
49873     } catch (std::out_of_range& e) {
49874       {
49875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49876       };
49877     } catch (std::exception& e) {
49878       {
49879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49880       };
49881     } catch (Dali::DaliException e) {
49882       {
49883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49884       };
49885     } catch (...) {
49886       {
49887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49888       };
49889     }
49890   }
49891
49892 }
49893
49894
49895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
49896   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49897   int arg2 ;
49898
49899   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49900   arg2 = (int)jarg2;
49901   {
49902     try {
49903       try {
49904         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
49905       }
49906       catch(std::out_of_range &_e) {
49907         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49908         return ;
49909       }
49910
49911     } catch (std::out_of_range& e) {
49912       {
49913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49914       };
49915     } catch (std::exception& e) {
49916       {
49917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49918       };
49919     } catch (Dali::DaliException e) {
49920       {
49921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49922       };
49923     } catch (...) {
49924       {
49925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49926       };
49927     }
49928   }
49929
49930 }
49931
49932
49933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
49934   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49935   int arg2 ;
49936   int arg3 ;
49937
49938   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49939   arg2 = (int)jarg2;
49940   arg3 = (int)jarg3;
49941   {
49942     try {
49943       try {
49944         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
49945       }
49946       catch(std::out_of_range &_e) {
49947         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49948         return ;
49949       }
49950       catch(std::invalid_argument &_e) {
49951         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49952         return ;
49953       }
49954
49955     } catch (std::out_of_range& e) {
49956       {
49957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49958       };
49959     } catch (std::exception& e) {
49960       {
49961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49962       };
49963     } catch (Dali::DaliException e) {
49964       {
49965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49966       };
49967     } catch (...) {
49968       {
49969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49970       };
49971     }
49972   }
49973
49974 }
49975
49976
49977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
49978   void * jresult ;
49979   Dali::TouchPoint *arg1 = 0 ;
49980   int arg2 ;
49981   std::vector< Dali::TouchPoint > *result = 0 ;
49982
49983   arg1 = (Dali::TouchPoint *)jarg1;
49984   if (!arg1) {
49985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49986     return 0;
49987   }
49988   arg2 = (int)jarg2;
49989   {
49990     try {
49991       try {
49992         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
49993       }
49994       catch(std::out_of_range &_e) {
49995         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49996         return 0;
49997       }
49998
49999     } catch (std::out_of_range& e) {
50000       {
50001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50002       };
50003     } catch (std::exception& e) {
50004       {
50005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50006       };
50007     } catch (Dali::DaliException e) {
50008       {
50009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50010       };
50011     } catch (...) {
50012       {
50013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50014       };
50015     }
50016   }
50017
50018   jresult = (void *)result;
50019   return jresult;
50020 }
50021
50022
50023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
50024   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
50025
50026   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
50027   {
50028     try {
50029       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
50030     } catch (std::out_of_range& e) {
50031       {
50032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50033       };
50034     } catch (std::exception& e) {
50035       {
50036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50037       };
50038     } catch (Dali::DaliException e) {
50039       {
50040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50041       };
50042     } catch (...) {
50043       {
50044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50045       };
50046     }
50047   }
50048
50049 }
50050
50051
50052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
50053   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
50054   int arg2 ;
50055   int arg3 ;
50056
50057   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
50058   arg2 = (int)jarg2;
50059   arg3 = (int)jarg3;
50060   {
50061     try {
50062       try {
50063         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
50064       }
50065       catch(std::out_of_range &_e) {
50066         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
50067         return ;
50068       }
50069       catch(std::invalid_argument &_e) {
50070         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
50071         return ;
50072       }
50073
50074     } catch (std::out_of_range& e) {
50075       {
50076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50077       };
50078     } catch (std::exception& e) {
50079       {
50080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50081       };
50082     } catch (Dali::DaliException e) {
50083       {
50084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50085       };
50086     } catch (...) {
50087       {
50088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50089       };
50090     }
50091   }
50092
50093 }
50094
50095
50096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
50097   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
50098   int arg2 ;
50099   std::vector< Dali::TouchPoint > *arg3 = 0 ;
50100
50101   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
50102   arg2 = (int)jarg2;
50103   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
50104   if (!arg3) {
50105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
50106     return ;
50107   }
50108   {
50109     try {
50110       try {
50111         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
50112       }
50113       catch(std::out_of_range &_e) {
50114         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
50115         return ;
50116       }
50117
50118     } catch (std::out_of_range& e) {
50119       {
50120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50121       };
50122     } catch (std::exception& e) {
50123       {
50124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50125       };
50126     } catch (Dali::DaliException e) {
50127       {
50128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50129       };
50130     } catch (...) {
50131       {
50132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50133       };
50134     }
50135   }
50136
50137 }
50138
50139
50140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
50141   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
50142
50143   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
50144   {
50145     try {
50146       delete arg1;
50147     } catch (std::out_of_range& e) {
50148       {
50149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50150       };
50151     } catch (std::exception& e) {
50152       {
50153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50154       };
50155     } catch (Dali::DaliException e) {
50156       {
50157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50158       };
50159     } catch (...) {
50160       {
50161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50162       };
50163     }
50164   }
50165
50166 }
50167
50168
50169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
50170   void * jresult ;
50171   Dali::Rect< int > *result = 0 ;
50172
50173   {
50174     try {
50175       result = (Dali::Rect< int > *)new Dali::Rect< int >();
50176     } catch (std::out_of_range& e) {
50177       {
50178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50179       };
50180     } catch (std::exception& e) {
50181       {
50182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50183       };
50184     } catch (Dali::DaliException e) {
50185       {
50186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50187       };
50188     } catch (...) {
50189       {
50190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50191       };
50192     }
50193   }
50194
50195   jresult = (void *)result;
50196   return jresult;
50197 }
50198
50199
50200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
50201   void * jresult ;
50202   int arg1 ;
50203   int arg2 ;
50204   int arg3 ;
50205   int arg4 ;
50206   Dali::Rect< int > *result = 0 ;
50207
50208   arg1 = (int)jarg1;
50209   arg2 = (int)jarg2;
50210   arg3 = (int)jarg3;
50211   arg4 = (int)jarg4;
50212   {
50213     try {
50214       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
50215     } catch (std::out_of_range& e) {
50216       {
50217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50218       };
50219     } catch (std::exception& e) {
50220       {
50221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50222       };
50223     } catch (Dali::DaliException e) {
50224       {
50225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50226       };
50227     } catch (...) {
50228       {
50229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50230       };
50231     }
50232   }
50233
50234   jresult = (void *)result;
50235   return jresult;
50236 }
50237
50238
50239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
50240   void * jresult ;
50241   Dali::Rect< int > *arg1 = 0 ;
50242   Dali::Rect< int > *result = 0 ;
50243
50244   arg1 = (Dali::Rect< int > *)jarg1;
50245   if (!arg1) {
50246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50247     return 0;
50248   }
50249   {
50250     try {
50251       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
50252     } catch (std::out_of_range& e) {
50253       {
50254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50255       };
50256     } catch (std::exception& e) {
50257       {
50258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50259       };
50260     } catch (Dali::DaliException e) {
50261       {
50262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50263       };
50264     } catch (...) {
50265       {
50266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50267       };
50268     }
50269   }
50270
50271   jresult = (void *)result;
50272   return jresult;
50273 }
50274
50275
50276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
50277   void * jresult ;
50278   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50279   Dali::Rect< int > *arg2 = 0 ;
50280   Dali::Rect< int > *result = 0 ;
50281
50282   arg1 = (Dali::Rect< int > *)jarg1;
50283   arg2 = (Dali::Rect< int > *)jarg2;
50284   if (!arg2) {
50285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50286     return 0;
50287   }
50288   {
50289     try {
50290       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
50291     } catch (std::out_of_range& e) {
50292       {
50293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50294       };
50295     } catch (std::exception& e) {
50296       {
50297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50298       };
50299     } catch (Dali::DaliException e) {
50300       {
50301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50302       };
50303     } catch (...) {
50304       {
50305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50306       };
50307     }
50308   }
50309
50310   jresult = (void *)result;
50311   return jresult;
50312 }
50313
50314
50315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
50316   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50317   int arg2 ;
50318   int arg3 ;
50319   int arg4 ;
50320   int arg5 ;
50321
50322   arg1 = (Dali::Rect< int > *)jarg1;
50323   arg2 = (int)jarg2;
50324   arg3 = (int)jarg3;
50325   arg4 = (int)jarg4;
50326   arg5 = (int)jarg5;
50327   {
50328     try {
50329       (arg1)->Set(arg2,arg3,arg4,arg5);
50330     } catch (std::out_of_range& e) {
50331       {
50332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50333       };
50334     } catch (std::exception& e) {
50335       {
50336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50337       };
50338     } catch (Dali::DaliException e) {
50339       {
50340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50341       };
50342     } catch (...) {
50343       {
50344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50345       };
50346     }
50347   }
50348
50349 }
50350
50351
50352 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
50353   unsigned int jresult ;
50354   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50355   bool result;
50356
50357   arg1 = (Dali::Rect< int > *)jarg1;
50358   {
50359     try {
50360       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
50361     } catch (std::out_of_range& e) {
50362       {
50363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50364       };
50365     } catch (std::exception& e) {
50366       {
50367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50368       };
50369     } catch (Dali::DaliException e) {
50370       {
50371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50372       };
50373     } catch (...) {
50374       {
50375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50376       };
50377     }
50378   }
50379
50380   jresult = result;
50381   return jresult;
50382 }
50383
50384
50385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
50386   int jresult ;
50387   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50388   int result;
50389
50390   arg1 = (Dali::Rect< int > *)jarg1;
50391   {
50392     try {
50393       result = (int)((Dali::Rect< int > const *)arg1)->Left();
50394     } catch (std::out_of_range& e) {
50395       {
50396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50397       };
50398     } catch (std::exception& e) {
50399       {
50400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50401       };
50402     } catch (Dali::DaliException e) {
50403       {
50404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50405       };
50406     } catch (...) {
50407       {
50408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50409       };
50410     }
50411   }
50412
50413   jresult = result;
50414   return jresult;
50415 }
50416
50417
50418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
50419   int jresult ;
50420   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50421   int result;
50422
50423   arg1 = (Dali::Rect< int > *)jarg1;
50424   {
50425     try {
50426       result = (int)((Dali::Rect< int > const *)arg1)->Right();
50427     } catch (std::out_of_range& e) {
50428       {
50429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50430       };
50431     } catch (std::exception& e) {
50432       {
50433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50434       };
50435     } catch (Dali::DaliException e) {
50436       {
50437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50438       };
50439     } catch (...) {
50440       {
50441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50442       };
50443     }
50444   }
50445
50446   jresult = result;
50447   return jresult;
50448 }
50449
50450
50451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
50452   int jresult ;
50453   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50454   int result;
50455
50456   arg1 = (Dali::Rect< int > *)jarg1;
50457   {
50458     try {
50459       result = (int)((Dali::Rect< int > const *)arg1)->Top();
50460     } catch (std::out_of_range& e) {
50461       {
50462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50463       };
50464     } catch (std::exception& e) {
50465       {
50466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50467       };
50468     } catch (Dali::DaliException e) {
50469       {
50470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50471       };
50472     } catch (...) {
50473       {
50474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50475       };
50476     }
50477   }
50478
50479   jresult = result;
50480   return jresult;
50481 }
50482
50483
50484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
50485   int jresult ;
50486   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50487   int result;
50488
50489   arg1 = (Dali::Rect< int > *)jarg1;
50490   {
50491     try {
50492       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
50493     } catch (std::out_of_range& e) {
50494       {
50495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50496       };
50497     } catch (std::exception& e) {
50498       {
50499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50500       };
50501     } catch (Dali::DaliException e) {
50502       {
50503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50504       };
50505     } catch (...) {
50506       {
50507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50508       };
50509     }
50510   }
50511
50512   jresult = result;
50513   return jresult;
50514 }
50515
50516
50517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
50518   int jresult ;
50519   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50520   int result;
50521
50522   arg1 = (Dali::Rect< int > *)jarg1;
50523   {
50524     try {
50525       result = (int)((Dali::Rect< int > const *)arg1)->Area();
50526     } catch (std::out_of_range& e) {
50527       {
50528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50529       };
50530     } catch (std::exception& e) {
50531       {
50532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50533       };
50534     } catch (Dali::DaliException e) {
50535       {
50536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50537       };
50538     } catch (...) {
50539       {
50540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50541       };
50542     }
50543   }
50544
50545   jresult = result;
50546   return jresult;
50547 }
50548
50549
50550 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
50551   unsigned int jresult ;
50552   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50553   Dali::Rect< int > *arg2 = 0 ;
50554   bool result;
50555
50556   arg1 = (Dali::Rect< int > *)jarg1;
50557   arg2 = (Dali::Rect< int > *)jarg2;
50558   if (!arg2) {
50559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50560     return 0;
50561   }
50562   {
50563     try {
50564       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
50565     } catch (std::out_of_range& e) {
50566       {
50567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50568       };
50569     } catch (std::exception& e) {
50570       {
50571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50572       };
50573     } catch (Dali::DaliException e) {
50574       {
50575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50576       };
50577     } catch (...) {
50578       {
50579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50580       };
50581     }
50582   }
50583
50584   jresult = result;
50585   return jresult;
50586 }
50587
50588
50589 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
50590   unsigned int jresult ;
50591   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50592   Dali::Rect< int > *arg2 = 0 ;
50593   bool result;
50594
50595   arg1 = (Dali::Rect< int > *)jarg1;
50596   arg2 = (Dali::Rect< int > *)jarg2;
50597   if (!arg2) {
50598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50599     return 0;
50600   }
50601   {
50602     try {
50603       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
50604     } catch (std::out_of_range& e) {
50605       {
50606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50607       };
50608     } catch (std::exception& e) {
50609       {
50610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50611       };
50612     } catch (Dali::DaliException e) {
50613       {
50614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50615       };
50616     } catch (...) {
50617       {
50618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50619       };
50620     }
50621   }
50622
50623   jresult = result;
50624   return jresult;
50625 }
50626
50627
50628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
50629   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50630   int arg2 ;
50631
50632   arg1 = (Dali::Rect< int > *)jarg1;
50633   arg2 = (int)jarg2;
50634   if (arg1) (arg1)->x = arg2;
50635 }
50636
50637
50638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
50639   int jresult ;
50640   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50641   int result;
50642
50643   arg1 = (Dali::Rect< int > *)jarg1;
50644   result = (int) ((arg1)->x);
50645   jresult = result;
50646   return jresult;
50647 }
50648
50649
50650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
50651   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50652   int arg2 ;
50653
50654   arg1 = (Dali::Rect< int > *)jarg1;
50655   arg2 = (int)jarg2;
50656   if (arg1) (arg1)->left = arg2;
50657 }
50658
50659
50660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
50661   int jresult ;
50662   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50663   int result;
50664
50665   arg1 = (Dali::Rect< int > *)jarg1;
50666   result = (int) ((arg1)->left);
50667   jresult = result;
50668   return jresult;
50669 }
50670
50671
50672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
50673   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50674   int arg2 ;
50675
50676   arg1 = (Dali::Rect< int > *)jarg1;
50677   arg2 = (int)jarg2;
50678   if (arg1) (arg1)->y = arg2;
50679 }
50680
50681
50682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
50683   int jresult ;
50684   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50685   int result;
50686
50687   arg1 = (Dali::Rect< int > *)jarg1;
50688   result = (int) ((arg1)->y);
50689   jresult = result;
50690   return jresult;
50691 }
50692
50693
50694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
50695   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50696   int arg2 ;
50697
50698   arg1 = (Dali::Rect< int > *)jarg1;
50699   arg2 = (int)jarg2;
50700   if (arg1) (arg1)->right = arg2;
50701 }
50702
50703
50704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
50705   int jresult ;
50706   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50707   int result;
50708
50709   arg1 = (Dali::Rect< int > *)jarg1;
50710   result = (int) ((arg1)->right);
50711   jresult = result;
50712   return jresult;
50713 }
50714
50715
50716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
50717   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50718   int arg2 ;
50719
50720   arg1 = (Dali::Rect< int > *)jarg1;
50721   arg2 = (int)jarg2;
50722   if (arg1) (arg1)->width = arg2;
50723 }
50724
50725
50726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
50727   int jresult ;
50728   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50729   int result;
50730
50731   arg1 = (Dali::Rect< int > *)jarg1;
50732   result = (int) ((arg1)->width);
50733   jresult = result;
50734   return jresult;
50735 }
50736
50737
50738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
50739   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50740   int arg2 ;
50741
50742   arg1 = (Dali::Rect< int > *)jarg1;
50743   arg2 = (int)jarg2;
50744   if (arg1) (arg1)->bottom = arg2;
50745 }
50746
50747
50748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
50749   int jresult ;
50750   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50751   int result;
50752
50753   arg1 = (Dali::Rect< int > *)jarg1;
50754   result = (int) ((arg1)->bottom);
50755   jresult = result;
50756   return jresult;
50757 }
50758
50759
50760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
50761   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50762   int arg2 ;
50763
50764   arg1 = (Dali::Rect< int > *)jarg1;
50765   arg2 = (int)jarg2;
50766   if (arg1) (arg1)->height = arg2;
50767 }
50768
50769
50770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
50771   int jresult ;
50772   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50773   int result;
50774
50775   arg1 = (Dali::Rect< int > *)jarg1;
50776   result = (int) ((arg1)->height);
50777   jresult = result;
50778   return jresult;
50779 }
50780
50781
50782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
50783   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50784   int arg2 ;
50785
50786   arg1 = (Dali::Rect< int > *)jarg1;
50787   arg2 = (int)jarg2;
50788   if (arg1) (arg1)->top = arg2;
50789 }
50790
50791
50792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
50793   int jresult ;
50794   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50795   int result;
50796
50797   arg1 = (Dali::Rect< int > *)jarg1;
50798   result = (int) ((arg1)->top);
50799   jresult = result;
50800   return jresult;
50801 }
50802
50803
50804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
50805   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50806
50807   arg1 = (Dali::Rect< int > *)jarg1;
50808   {
50809     try {
50810       delete arg1;
50811     } catch (std::out_of_range& e) {
50812       {
50813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50814       };
50815     } catch (std::exception& e) {
50816       {
50817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50818       };
50819     } catch (Dali::DaliException e) {
50820       {
50821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50822       };
50823     } catch (...) {
50824       {
50825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50826       };
50827     }
50828   }
50829
50830 }
50831
50832
50833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
50834   void * jresult ;
50835   Dali::Rect< float > *result = 0 ;
50836
50837   {
50838     try {
50839       result = (Dali::Rect< float > *)new Dali::Rect< float >();
50840     } catch (std::out_of_range& e) {
50841       {
50842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50843       };
50844     } catch (std::exception& e) {
50845       {
50846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50847       };
50848     } catch (Dali::DaliException e) {
50849       {
50850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50851       };
50852     } catch (...) {
50853       {
50854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50855       };
50856     }
50857   }
50858
50859   jresult = (void *)result;
50860   return jresult;
50861 }
50862
50863
50864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
50865   void * jresult ;
50866   float arg1 ;
50867   float arg2 ;
50868   float arg3 ;
50869   float arg4 ;
50870   Dali::Rect< float > *result = 0 ;
50871
50872   arg1 = (float)jarg1;
50873   arg2 = (float)jarg2;
50874   arg3 = (float)jarg4;
50875   arg4 = (float)jarg3;
50876   {
50877     try {
50878       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
50879     } catch (std::out_of_range& e) {
50880       {
50881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50882       };
50883     } catch (std::exception& e) {
50884       {
50885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50886       };
50887     } catch (Dali::DaliException e) {
50888       {
50889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50890       };
50891     } catch (...) {
50892       {
50893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50894       };
50895     }
50896   }
50897
50898   jresult = (void *)result;
50899   return jresult;
50900 }
50901
50902
50903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
50904   void * jresult ;
50905   Dali::Rect< float > *arg1 = 0 ;
50906   Dali::Rect< float > *result = 0 ;
50907
50908   arg1 = (Dali::Rect< float > *)jarg1;
50909   if (!arg1) {
50910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50911     return 0;
50912   }
50913   {
50914     try {
50915       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
50916     } catch (std::out_of_range& e) {
50917       {
50918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50919       };
50920     } catch (std::exception& e) {
50921       {
50922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50923       };
50924     } catch (Dali::DaliException e) {
50925       {
50926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50927       };
50928     } catch (...) {
50929       {
50930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50931       };
50932     }
50933   }
50934
50935   jresult = (void *)result;
50936   return jresult;
50937 }
50938
50939
50940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
50941   void * jresult ;
50942   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50943   Dali::Rect< float > *arg2 = 0 ;
50944   Dali::Rect< float > *result = 0 ;
50945
50946   arg1 = (Dali::Rect< float > *)jarg1;
50947   arg2 = (Dali::Rect< float > *)jarg2;
50948   if (!arg2) {
50949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50950     return 0;
50951   }
50952   {
50953     try {
50954       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*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_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
50980   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50981   float arg2 ;
50982   float arg3 ;
50983   float arg4 ;
50984   float arg5 ;
50985
50986   arg1 = (Dali::Rect< float > *)jarg1;
50987   arg2 = (float)jarg2;
50988   arg3 = (float)jarg3;
50989   arg4 = (float)jarg5;
50990   arg5 = (float)jarg4;
50991   {
50992     try {
50993       (arg1)->Set(arg2,arg3,arg4,arg5);
50994     } catch (std::out_of_range& e) {
50995       {
50996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50997       };
50998     } catch (std::exception& e) {
50999       {
51000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51001       };
51002     } catch (Dali::DaliException e) {
51003       {
51004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51005       };
51006     } catch (...) {
51007       {
51008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51009       };
51010     }
51011   }
51012
51013 }
51014
51015
51016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
51017   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51018   float arg2 ;
51019
51020   arg1 = (Dali::Rect< float > *)jarg1;
51021   arg2 = (float)jarg2;
51022   if (arg1) (arg1)->left = arg2;
51023 }
51024
51025
51026 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
51027   float jresult ;
51028   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51029   float result;
51030
51031   arg1 = (Dali::Rect< float > *)jarg1;
51032   result = (float) ((arg1)->left);
51033   jresult = result;
51034   return jresult;
51035 }
51036
51037
51038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
51039   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51040   float arg2 ;
51041
51042   arg1 = (Dali::Rect< float > *)jarg1;
51043   arg2 = (float)jarg2;
51044   if (arg1) (arg1)->left = arg2;
51045 }
51046
51047
51048 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
51049   float jresult ;
51050   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51051   float result;
51052
51053   arg1 = (Dali::Rect< float > *)jarg1;
51054   result = (float) ((arg1)->left);
51055   jresult = result;
51056   return jresult;
51057 }
51058
51059
51060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
51061   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51062   float arg2 ;
51063
51064   arg1 = (Dali::Rect< float > *)jarg1;
51065   arg2 = (float)jarg2;
51066   if (arg1) (arg1)->right = arg2;
51067 }
51068
51069
51070 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
51071   float jresult ;
51072   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51073   float result;
51074
51075   arg1 = (Dali::Rect< float > *)jarg1;
51076   result = (float) ((arg1)->right);
51077   jresult = result;
51078   return jresult;
51079 }
51080
51081
51082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
51083   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51084   float arg2 ;
51085
51086   arg1 = (Dali::Rect< float > *)jarg1;
51087   arg2 = (float)jarg2;
51088   if (arg1) (arg1)->right = arg2;
51089 }
51090
51091
51092 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
51093   float jresult ;
51094   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51095   float result;
51096
51097   arg1 = (Dali::Rect< float > *)jarg1;
51098   result = (float) ((arg1)->right);
51099   jresult = result;
51100   return jresult;
51101 }
51102
51103
51104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
51105   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51106   float arg2 ;
51107
51108   arg1 = (Dali::Rect< float > *)jarg1;
51109   arg2 = (float)jarg2;
51110   if (arg1) (arg1)->bottom = arg2;
51111 }
51112
51113
51114 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
51115   float jresult ;
51116   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51117   float result;
51118
51119   arg1 = (Dali::Rect< float > *)jarg1;
51120   result = (float) ((arg1)->bottom);
51121   jresult = result;
51122   return jresult;
51123 }
51124
51125
51126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
51127   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51128   float arg2 ;
51129
51130   arg1 = (Dali::Rect< float > *)jarg1;
51131   arg2 = (float)jarg2;
51132   if (arg1) (arg1)->top = arg2;
51133 }
51134
51135
51136 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
51137   float jresult ;
51138   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51139   float result;
51140
51141   arg1 = (Dali::Rect< float > *)jarg1;
51142   result = (float) ((arg1)->top);
51143   jresult = result;
51144   return jresult;
51145 }
51146
51147
51148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
51149   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51150
51151   arg1 = (Dali::Rect< float > *)jarg1;
51152   {
51153     try {
51154       delete arg1;
51155     } catch (std::out_of_range& e) {
51156       {
51157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51158       };
51159     } catch (std::exception& e) {
51160       {
51161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51162       };
51163     } catch (Dali::DaliException e) {
51164       {
51165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51166       };
51167     } catch (...) {
51168       {
51169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51170       };
51171     }
51172   }
51173
51174 }
51175
51176
51177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
51178   int jresult ;
51179   int result;
51180
51181   result = (int)Dali::Vector< int >::BaseType;
51182   jresult = (int)result;
51183   return jresult;
51184 }
51185
51186
51187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
51188   void * jresult ;
51189   Dali::Vector< int > *result = 0 ;
51190
51191   {
51192     try {
51193       result = (Dali::Vector< int > *)new Dali::Vector< int >();
51194     } catch (std::out_of_range& e) {
51195       {
51196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51197       };
51198     } catch (std::exception& e) {
51199       {
51200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51201       };
51202     } catch (Dali::DaliException e) {
51203       {
51204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51205       };
51206     } catch (...) {
51207       {
51208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51209       };
51210     }
51211   }
51212
51213   jresult = (void *)result;
51214   return jresult;
51215 }
51216
51217
51218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
51219   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51220
51221   arg1 = (Dali::Vector< int > *)jarg1;
51222   {
51223     try {
51224       delete arg1;
51225     } catch (std::out_of_range& e) {
51226       {
51227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51228       };
51229     } catch (std::exception& e) {
51230       {
51231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51232       };
51233     } catch (Dali::DaliException e) {
51234       {
51235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51236       };
51237     } catch (...) {
51238       {
51239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51240       };
51241     }
51242   }
51243
51244 }
51245
51246
51247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
51248   void * jresult ;
51249   Dali::Vector< int > *arg1 = 0 ;
51250   Dali::Vector< int > *result = 0 ;
51251
51252   arg1 = (Dali::Vector< int > *)jarg1;
51253   if (!arg1) {
51254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51255     return 0;
51256   }
51257   {
51258     try {
51259       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
51260     } catch (std::out_of_range& e) {
51261       {
51262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51263       };
51264     } catch (std::exception& e) {
51265       {
51266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51267       };
51268     } catch (Dali::DaliException e) {
51269       {
51270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51271       };
51272     } catch (...) {
51273       {
51274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51275       };
51276     }
51277   }
51278
51279   jresult = (void *)result;
51280   return jresult;
51281 }
51282
51283
51284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
51285   void * jresult ;
51286   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51287   Dali::Vector< int > *arg2 = 0 ;
51288   Dali::Vector< int > *result = 0 ;
51289
51290   arg1 = (Dali::Vector< int > *)jarg1;
51291   arg2 = (Dali::Vector< int > *)jarg2;
51292   if (!arg2) {
51293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51294     return 0;
51295   }
51296   {
51297     try {
51298       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
51299     } catch (std::out_of_range& e) {
51300       {
51301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51302       };
51303     } catch (std::exception& e) {
51304       {
51305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51306       };
51307     } catch (Dali::DaliException e) {
51308       {
51309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51310       };
51311     } catch (...) {
51312       {
51313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51314       };
51315     }
51316   }
51317
51318   jresult = (void *)result;
51319   return jresult;
51320 }
51321
51322
51323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
51324   void * jresult ;
51325   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51326   Dali::Vector< int >::Iterator result;
51327
51328   arg1 = (Dali::Vector< int > *)jarg1;
51329   {
51330     try {
51331       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
51332     } catch (std::out_of_range& e) {
51333       {
51334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51335       };
51336     } catch (std::exception& e) {
51337       {
51338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51339       };
51340     } catch (Dali::DaliException e) {
51341       {
51342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51343       };
51344     } catch (...) {
51345       {
51346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51347       };
51348     }
51349   }
51350
51351   jresult = (void *)result;
51352   return jresult;
51353 }
51354
51355
51356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
51357   void * jresult ;
51358   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51359   Dali::Vector< int >::Iterator result;
51360
51361   arg1 = (Dali::Vector< int > *)jarg1;
51362   {
51363     try {
51364       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
51365     } catch (std::out_of_range& e) {
51366       {
51367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51368       };
51369     } catch (std::exception& e) {
51370       {
51371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51372       };
51373     } catch (Dali::DaliException e) {
51374       {
51375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51376       };
51377     } catch (...) {
51378       {
51379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51380       };
51381     }
51382   }
51383
51384   jresult = (void *)result;
51385   return jresult;
51386 }
51387
51388
51389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51390   void * jresult ;
51391   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51392   Dali::Vector< int >::SizeType arg2 ;
51393   Dali::Vector< int >::ItemType *result = 0 ;
51394
51395   arg1 = (Dali::Vector< int > *)jarg1;
51396   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51397   {
51398     try {
51399       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
51400     } catch (std::out_of_range& e) {
51401       {
51402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51403       };
51404     } catch (std::exception& e) {
51405       {
51406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51407       };
51408     } catch (Dali::DaliException e) {
51409       {
51410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51411       };
51412     } catch (...) {
51413       {
51414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51415       };
51416     }
51417   }
51418
51419   jresult = (void *)result;
51420   return jresult;
51421 }
51422
51423
51424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
51425   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51426   Dali::Vector< int >::ItemType *arg2 = 0 ;
51427   Dali::Vector< int >::ItemType temp2 ;
51428
51429   arg1 = (Dali::Vector< int > *)jarg1;
51430   temp2 = (Dali::Vector< int >::ItemType)jarg2;
51431   arg2 = &temp2;
51432   {
51433     try {
51434       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
51435     } catch (std::out_of_range& e) {
51436       {
51437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51438       };
51439     } catch (std::exception& e) {
51440       {
51441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51442       };
51443     } catch (Dali::DaliException e) {
51444       {
51445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51446       };
51447     } catch (...) {
51448       {
51449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51450       };
51451     }
51452   }
51453
51454 }
51455
51456
51457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
51458   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51459   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51460   Dali::Vector< int >::ItemType *arg3 = 0 ;
51461   Dali::Vector< int >::ItemType temp3 ;
51462
51463   arg1 = (Dali::Vector< int > *)jarg1;
51464   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51465   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51466   arg3 = &temp3;
51467   {
51468     try {
51469       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51470     } catch (std::out_of_range& e) {
51471       {
51472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51473       };
51474     } catch (std::exception& e) {
51475       {
51476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51477       };
51478     } catch (Dali::DaliException e) {
51479       {
51480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51481       };
51482     } catch (...) {
51483       {
51484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51485       };
51486     }
51487   }
51488
51489 }
51490
51491
51492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51493   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51494   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51495   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51496   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
51497
51498   arg1 = (Dali::Vector< int > *)jarg1;
51499   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51500   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51501   arg4 = (Dali::Vector< int >::Iterator)jarg4;
51502   {
51503     try {
51504       (arg1)->Insert(arg2,arg3,arg4);
51505     } catch (std::out_of_range& e) {
51506       {
51507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51508       };
51509     } catch (std::exception& e) {
51510       {
51511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51512       };
51513     } catch (Dali::DaliException e) {
51514       {
51515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51516       };
51517     } catch (...) {
51518       {
51519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51520       };
51521     }
51522   }
51523
51524 }
51525
51526
51527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
51528   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51529   Dali::Vector< int >::SizeType arg2 ;
51530
51531   arg1 = (Dali::Vector< int > *)jarg1;
51532   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51533   {
51534     try {
51535       (arg1)->Reserve(arg2);
51536     } catch (std::out_of_range& e) {
51537       {
51538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51539       };
51540     } catch (std::exception& e) {
51541       {
51542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51543       };
51544     } catch (Dali::DaliException e) {
51545       {
51546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51547       };
51548     } catch (...) {
51549       {
51550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51551       };
51552     }
51553   }
51554
51555 }
51556
51557
51558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51559   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51560   Dali::Vector< int >::SizeType arg2 ;
51561
51562   arg1 = (Dali::Vector< int > *)jarg1;
51563   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51564   {
51565     try {
51566       (arg1)->Resize(arg2);
51567     } catch (std::out_of_range& e) {
51568       {
51569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51570       };
51571     } catch (std::exception& e) {
51572       {
51573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51574       };
51575     } catch (Dali::DaliException e) {
51576       {
51577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51578       };
51579     } catch (...) {
51580       {
51581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51582       };
51583     }
51584   }
51585
51586 }
51587
51588
51589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
51590   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51591   Dali::Vector< int >::SizeType arg2 ;
51592   Dali::Vector< int >::ItemType *arg3 = 0 ;
51593   Dali::Vector< int >::ItemType temp3 ;
51594
51595   arg1 = (Dali::Vector< int > *)jarg1;
51596   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51597   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51598   arg3 = &temp3;
51599   {
51600     try {
51601       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51602     } catch (std::out_of_range& e) {
51603       {
51604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51605       };
51606     } catch (std::exception& e) {
51607       {
51608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51609       };
51610     } catch (Dali::DaliException e) {
51611       {
51612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51613       };
51614     } catch (...) {
51615       {
51616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51617       };
51618     }
51619   }
51620
51621 }
51622
51623
51624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
51625   void * jresult ;
51626   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51627   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51628   Dali::Vector< int >::Iterator result;
51629
51630   arg1 = (Dali::Vector< int > *)jarg1;
51631   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51632   {
51633     try {
51634       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
51635     } catch (std::out_of_range& e) {
51636       {
51637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51638       };
51639     } catch (std::exception& e) {
51640       {
51641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51642       };
51643     } catch (Dali::DaliException e) {
51644       {
51645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51646       };
51647     } catch (...) {
51648       {
51649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51650       };
51651     }
51652   }
51653
51654   jresult = (void *)result;
51655   return jresult;
51656 }
51657
51658
51659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51660   void * jresult ;
51661   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51662   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51663   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51664   Dali::Vector< int >::Iterator result;
51665
51666   arg1 = (Dali::Vector< int > *)jarg1;
51667   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51668   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51669   {
51670     try {
51671       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
51672     } catch (std::out_of_range& e) {
51673       {
51674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51675       };
51676     } catch (std::exception& e) {
51677       {
51678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51679       };
51680     } catch (Dali::DaliException e) {
51681       {
51682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51683       };
51684     } catch (...) {
51685       {
51686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51687       };
51688     }
51689   }
51690
51691   jresult = (void *)result;
51692   return jresult;
51693 }
51694
51695
51696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
51697   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51698   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51699
51700   arg1 = (Dali::Vector< int > *)jarg1;
51701   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51702   {
51703     try {
51704       (arg1)->Remove(arg2);
51705     } catch (std::out_of_range& e) {
51706       {
51707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51708       };
51709     } catch (std::exception& e) {
51710       {
51711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51712       };
51713     } catch (Dali::DaliException e) {
51714       {
51715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51716       };
51717     } catch (...) {
51718       {
51719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51720       };
51721     }
51722   }
51723
51724 }
51725
51726
51727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
51728   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51729   Dali::Vector< int > *arg2 = 0 ;
51730
51731   arg1 = (Dali::Vector< int > *)jarg1;
51732   arg2 = (Dali::Vector< int > *)jarg2;
51733   if (!arg2) {
51734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
51735     return ;
51736   }
51737   {
51738     try {
51739       (arg1)->Swap(*arg2);
51740     } catch (std::out_of_range& e) {
51741       {
51742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51743       };
51744     } catch (std::exception& e) {
51745       {
51746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51747       };
51748     } catch (Dali::DaliException e) {
51749       {
51750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51751       };
51752     } catch (...) {
51753       {
51754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51755       };
51756     }
51757   }
51758
51759 }
51760
51761
51762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
51763   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51764
51765   arg1 = (Dali::Vector< int > *)jarg1;
51766   {
51767     try {
51768       (arg1)->Clear();
51769     } catch (std::out_of_range& e) {
51770       {
51771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51772       };
51773     } catch (std::exception& e) {
51774       {
51775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51776       };
51777     } catch (Dali::DaliException e) {
51778       {
51779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51780       };
51781     } catch (...) {
51782       {
51783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51784       };
51785     }
51786   }
51787
51788 }
51789
51790
51791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
51792   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51793
51794   arg1 = (Dali::Vector< int > *)jarg1;
51795   {
51796     try {
51797       (arg1)->Release();
51798     } catch (std::out_of_range& e) {
51799       {
51800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51801       };
51802     } catch (std::exception& e) {
51803       {
51804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51805       };
51806     } catch (Dali::DaliException e) {
51807       {
51808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51809       };
51810     } catch (...) {
51811       {
51812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51813       };
51814     }
51815   }
51816
51817 }
51818
51819
51820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
51821   int jresult ;
51822   int result;
51823
51824   result = (int)Dali::Vector< float >::BaseType;
51825   jresult = (int)result;
51826   return jresult;
51827 }
51828
51829
51830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
51831   void * jresult ;
51832   Dali::Vector< float > *result = 0 ;
51833
51834   {
51835     try {
51836       result = (Dali::Vector< float > *)new Dali::Vector< float >();
51837     } catch (std::out_of_range& e) {
51838       {
51839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51840       };
51841     } catch (std::exception& e) {
51842       {
51843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51844       };
51845     } catch (Dali::DaliException e) {
51846       {
51847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51848       };
51849     } catch (...) {
51850       {
51851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51852       };
51853     }
51854   }
51855
51856   jresult = (void *)result;
51857   return jresult;
51858 }
51859
51860
51861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
51862   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51863
51864   arg1 = (Dali::Vector< float > *)jarg1;
51865   {
51866     try {
51867       delete arg1;
51868     } catch (std::out_of_range& e) {
51869       {
51870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51871       };
51872     } catch (std::exception& e) {
51873       {
51874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51875       };
51876     } catch (Dali::DaliException e) {
51877       {
51878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51879       };
51880     } catch (...) {
51881       {
51882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51883       };
51884     }
51885   }
51886
51887 }
51888
51889
51890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
51891   void * jresult ;
51892   Dali::Vector< float > *arg1 = 0 ;
51893   Dali::Vector< float > *result = 0 ;
51894
51895   arg1 = (Dali::Vector< float > *)jarg1;
51896   if (!arg1) {
51897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51898     return 0;
51899   }
51900   {
51901     try {
51902       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
51903     } catch (std::out_of_range& e) {
51904       {
51905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51906       };
51907     } catch (std::exception& e) {
51908       {
51909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51910       };
51911     } catch (Dali::DaliException e) {
51912       {
51913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51914       };
51915     } catch (...) {
51916       {
51917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51918       };
51919     }
51920   }
51921
51922   jresult = (void *)result;
51923   return jresult;
51924 }
51925
51926
51927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
51928   void * jresult ;
51929   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51930   Dali::Vector< float > *arg2 = 0 ;
51931   Dali::Vector< float > *result = 0 ;
51932
51933   arg1 = (Dali::Vector< float > *)jarg1;
51934   arg2 = (Dali::Vector< float > *)jarg2;
51935   if (!arg2) {
51936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51937     return 0;
51938   }
51939   {
51940     try {
51941       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
51942     } catch (std::out_of_range& e) {
51943       {
51944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51945       };
51946     } catch (std::exception& e) {
51947       {
51948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51949       };
51950     } catch (Dali::DaliException e) {
51951       {
51952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51953       };
51954     } catch (...) {
51955       {
51956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51957       };
51958     }
51959   }
51960
51961   jresult = (void *)result;
51962   return jresult;
51963 }
51964
51965
51966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
51967   void * jresult ;
51968   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51969   Dali::Vector< float >::Iterator result;
51970
51971   arg1 = (Dali::Vector< float > *)jarg1;
51972   {
51973     try {
51974       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
51975     } catch (std::out_of_range& e) {
51976       {
51977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51978       };
51979     } catch (std::exception& e) {
51980       {
51981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51982       };
51983     } catch (Dali::DaliException e) {
51984       {
51985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51986       };
51987     } catch (...) {
51988       {
51989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51990       };
51991     }
51992   }
51993
51994   jresult = (void *)result;
51995   return jresult;
51996 }
51997
51998
51999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
52000   void * jresult ;
52001   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52002   Dali::Vector< float >::Iterator result;
52003
52004   arg1 = (Dali::Vector< float > *)jarg1;
52005   {
52006     try {
52007       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
52008     } catch (std::out_of_range& e) {
52009       {
52010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52011       };
52012     } catch (std::exception& e) {
52013       {
52014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52015       };
52016     } catch (Dali::DaliException e) {
52017       {
52018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52019       };
52020     } catch (...) {
52021       {
52022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52023       };
52024     }
52025   }
52026
52027   jresult = (void *)result;
52028   return jresult;
52029 }
52030
52031
52032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52033   void * jresult ;
52034   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52035   Dali::Vector< float >::SizeType arg2 ;
52036   Dali::Vector< float >::ItemType *result = 0 ;
52037
52038   arg1 = (Dali::Vector< float > *)jarg1;
52039   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52040   {
52041     try {
52042       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
52043     } catch (std::out_of_range& e) {
52044       {
52045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52046       };
52047     } catch (std::exception& e) {
52048       {
52049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52050       };
52051     } catch (Dali::DaliException e) {
52052       {
52053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52054       };
52055     } catch (...) {
52056       {
52057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52058       };
52059     }
52060   }
52061
52062   jresult = (void *)result;
52063   return jresult;
52064 }
52065
52066
52067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
52068   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52069   Dali::Vector< float >::ItemType *arg2 = 0 ;
52070   Dali::Vector< float >::ItemType temp2 ;
52071
52072   arg1 = (Dali::Vector< float > *)jarg1;
52073   temp2 = (Dali::Vector< float >::ItemType)jarg2;
52074   arg2 = &temp2;
52075   {
52076     try {
52077       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
52078     } catch (std::out_of_range& e) {
52079       {
52080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52081       };
52082     } catch (std::exception& e) {
52083       {
52084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52085       };
52086     } catch (Dali::DaliException e) {
52087       {
52088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52089       };
52090     } catch (...) {
52091       {
52092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52093       };
52094     }
52095   }
52096
52097 }
52098
52099
52100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
52101   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52102   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52103   Dali::Vector< float >::ItemType *arg3 = 0 ;
52104   Dali::Vector< float >::ItemType temp3 ;
52105
52106   arg1 = (Dali::Vector< float > *)jarg1;
52107   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52108   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52109   arg3 = &temp3;
52110   {
52111     try {
52112       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52113     } catch (std::out_of_range& e) {
52114       {
52115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52116       };
52117     } catch (std::exception& e) {
52118       {
52119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52120       };
52121     } catch (Dali::DaliException e) {
52122       {
52123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52124       };
52125     } catch (...) {
52126       {
52127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52128       };
52129     }
52130   }
52131
52132 }
52133
52134
52135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
52136   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52137   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52138   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52139   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
52140
52141   arg1 = (Dali::Vector< float > *)jarg1;
52142   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52143   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52144   arg4 = (Dali::Vector< float >::Iterator)jarg4;
52145   {
52146     try {
52147       (arg1)->Insert(arg2,arg3,arg4);
52148     } catch (std::out_of_range& e) {
52149       {
52150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52151       };
52152     } catch (std::exception& e) {
52153       {
52154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52155       };
52156     } catch (Dali::DaliException e) {
52157       {
52158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52159       };
52160     } catch (...) {
52161       {
52162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52163       };
52164     }
52165   }
52166
52167 }
52168
52169
52170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
52171   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52172   Dali::Vector< float >::SizeType arg2 ;
52173
52174   arg1 = (Dali::Vector< float > *)jarg1;
52175   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52176   {
52177     try {
52178       (arg1)->Reserve(arg2);
52179     } catch (std::out_of_range& e) {
52180       {
52181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52182       };
52183     } catch (std::exception& e) {
52184       {
52185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52186       };
52187     } catch (Dali::DaliException e) {
52188       {
52189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52190       };
52191     } catch (...) {
52192       {
52193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52194       };
52195     }
52196   }
52197
52198 }
52199
52200 //// ========================= end of part 2 =============================
52201
52202 //// ========================== start part 3 ===============================
52203
52204
52205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52206   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52207   Dali::Vector< float >::SizeType arg2 ;
52208
52209   arg1 = (Dali::Vector< float > *)jarg1;
52210   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52211   {
52212     try {
52213       (arg1)->Resize(arg2);
52214     } catch (std::out_of_range& e) {
52215       {
52216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52217       };
52218     } catch (std::exception& e) {
52219       {
52220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52221       };
52222     } catch (Dali::DaliException e) {
52223       {
52224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52225       };
52226     } catch (...) {
52227       {
52228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52229       };
52230     }
52231   }
52232
52233 }
52234
52235
52236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
52237   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52238   Dali::Vector< float >::SizeType arg2 ;
52239   Dali::Vector< float >::ItemType *arg3 = 0 ;
52240   Dali::Vector< float >::ItemType temp3 ;
52241
52242   arg1 = (Dali::Vector< float > *)jarg1;
52243   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52244   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52245   arg3 = &temp3;
52246   {
52247     try {
52248       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52249     } catch (std::out_of_range& e) {
52250       {
52251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52252       };
52253     } catch (std::exception& e) {
52254       {
52255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52256       };
52257     } catch (Dali::DaliException e) {
52258       {
52259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52260       };
52261     } catch (...) {
52262       {
52263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52264       };
52265     }
52266   }
52267
52268 }
52269
52270
52271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
52272   void * jresult ;
52273   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52274   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52275   Dali::Vector< float >::Iterator result;
52276
52277   arg1 = (Dali::Vector< float > *)jarg1;
52278   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52279   {
52280     try {
52281       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
52282     } catch (std::out_of_range& e) {
52283       {
52284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52285       };
52286     } catch (std::exception& e) {
52287       {
52288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52289       };
52290     } catch (Dali::DaliException e) {
52291       {
52292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52293       };
52294     } catch (...) {
52295       {
52296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52297       };
52298     }
52299   }
52300
52301   jresult = (void *)result;
52302   return jresult;
52303 }
52304
52305
52306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
52307   void * jresult ;
52308   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52309   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52310   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52311   Dali::Vector< float >::Iterator result;
52312
52313   arg1 = (Dali::Vector< float > *)jarg1;
52314   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52315   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52316   {
52317     try {
52318       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
52319     } catch (std::out_of_range& e) {
52320       {
52321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52322       };
52323     } catch (std::exception& e) {
52324       {
52325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52326       };
52327     } catch (Dali::DaliException e) {
52328       {
52329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52330       };
52331     } catch (...) {
52332       {
52333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52334       };
52335     }
52336   }
52337
52338   jresult = (void *)result;
52339   return jresult;
52340 }
52341
52342
52343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
52344   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52345   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52346
52347   arg1 = (Dali::Vector< float > *)jarg1;
52348   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52349   {
52350     try {
52351       (arg1)->Remove(arg2);
52352     } catch (std::out_of_range& e) {
52353       {
52354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52355       };
52356     } catch (std::exception& e) {
52357       {
52358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52359       };
52360     } catch (Dali::DaliException e) {
52361       {
52362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52363       };
52364     } catch (...) {
52365       {
52366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52367       };
52368     }
52369   }
52370
52371 }
52372
52373
52374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
52375   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52376   Dali::Vector< float > *arg2 = 0 ;
52377
52378   arg1 = (Dali::Vector< float > *)jarg1;
52379   arg2 = (Dali::Vector< float > *)jarg2;
52380   if (!arg2) {
52381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
52382     return ;
52383   }
52384   {
52385     try {
52386       (arg1)->Swap(*arg2);
52387     } catch (std::out_of_range& e) {
52388       {
52389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52390       };
52391     } catch (std::exception& e) {
52392       {
52393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52394       };
52395     } catch (Dali::DaliException e) {
52396       {
52397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52398       };
52399     } catch (...) {
52400       {
52401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52402       };
52403     }
52404   }
52405
52406 }
52407
52408
52409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
52410   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52411
52412   arg1 = (Dali::Vector< float > *)jarg1;
52413   {
52414     try {
52415       (arg1)->Clear();
52416     } catch (std::out_of_range& e) {
52417       {
52418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52419       };
52420     } catch (std::exception& e) {
52421       {
52422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52423       };
52424     } catch (Dali::DaliException e) {
52425       {
52426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52427       };
52428     } catch (...) {
52429       {
52430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52431       };
52432     }
52433   }
52434
52435 }
52436
52437
52438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
52439   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52440
52441   arg1 = (Dali::Vector< float > *)jarg1;
52442   {
52443     try {
52444       (arg1)->Release();
52445     } catch (std::out_of_range& e) {
52446       {
52447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52448       };
52449     } catch (std::exception& e) {
52450       {
52451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52452       };
52453     } catch (Dali::DaliException e) {
52454       {
52455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52456       };
52457     } catch (...) {
52458       {
52459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52460       };
52461     }
52462   }
52463
52464 }
52465
52466
52467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
52468   int jresult ;
52469   int result;
52470
52471   result = (int)Dali::Vector< unsigned char >::BaseType;
52472   jresult = (int)result;
52473   return jresult;
52474 }
52475
52476
52477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
52478   void * jresult ;
52479   Dali::Vector< unsigned char > *result = 0 ;
52480
52481   {
52482     try {
52483       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
52484     } catch (std::out_of_range& e) {
52485       {
52486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52487       };
52488     } catch (std::exception& e) {
52489       {
52490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52491       };
52492     } catch (Dali::DaliException e) {
52493       {
52494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52495       };
52496     } catch (...) {
52497       {
52498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52499       };
52500     }
52501   }
52502
52503   jresult = (void *)result;
52504   return jresult;
52505 }
52506
52507
52508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
52509   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52510
52511   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52512   {
52513     try {
52514       delete arg1;
52515     } catch (std::out_of_range& e) {
52516       {
52517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52518       };
52519     } catch (std::exception& e) {
52520       {
52521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52522       };
52523     } catch (Dali::DaliException e) {
52524       {
52525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52526       };
52527     } catch (...) {
52528       {
52529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52530       };
52531     }
52532   }
52533
52534 }
52535
52536
52537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
52538   void * jresult ;
52539   Dali::Vector< unsigned char > *arg1 = 0 ;
52540   Dali::Vector< unsigned char > *result = 0 ;
52541
52542   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52543   if (!arg1) {
52544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52545     return 0;
52546   }
52547   {
52548     try {
52549       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
52550     } catch (std::out_of_range& e) {
52551       {
52552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52553       };
52554     } catch (std::exception& e) {
52555       {
52556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52557       };
52558     } catch (Dali::DaliException e) {
52559       {
52560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52561       };
52562     } catch (...) {
52563       {
52564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52565       };
52566     }
52567   }
52568
52569   jresult = (void *)result;
52570   return jresult;
52571 }
52572
52573
52574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
52575   void * jresult ;
52576   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52577   Dali::Vector< unsigned char > *arg2 = 0 ;
52578   Dali::Vector< unsigned char > *result = 0 ;
52579
52580   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52581   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52582   if (!arg2) {
52583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52584     return 0;
52585   }
52586   {
52587     try {
52588       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
52589     } catch (std::out_of_range& e) {
52590       {
52591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52592       };
52593     } catch (std::exception& e) {
52594       {
52595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52596       };
52597     } catch (Dali::DaliException e) {
52598       {
52599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52600       };
52601     } catch (...) {
52602       {
52603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52604       };
52605     }
52606   }
52607
52608   jresult = (void *)result;
52609   return jresult;
52610 }
52611
52612
52613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
52614   void * jresult ;
52615   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52616   Dali::Vector< unsigned char >::Iterator result;
52617
52618   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52619   {
52620     try {
52621       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
52622     } catch (std::out_of_range& e) {
52623       {
52624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52625       };
52626     } catch (std::exception& e) {
52627       {
52628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52629       };
52630     } catch (Dali::DaliException e) {
52631       {
52632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52633       };
52634     } catch (...) {
52635       {
52636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52637       };
52638     }
52639   }
52640
52641   jresult = (void *)result;
52642   return jresult;
52643 }
52644
52645
52646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
52647   void * jresult ;
52648   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52649   Dali::Vector< unsigned char >::Iterator result;
52650
52651   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52652   {
52653     try {
52654       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
52655     } catch (std::out_of_range& e) {
52656       {
52657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52658       };
52659     } catch (std::exception& e) {
52660       {
52661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52662       };
52663     } catch (Dali::DaliException e) {
52664       {
52665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52666       };
52667     } catch (...) {
52668       {
52669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52670       };
52671     }
52672   }
52673
52674   jresult = (void *)result;
52675   return jresult;
52676 }
52677
52678
52679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52680   void * jresult ;
52681   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52682   Dali::Vector< unsigned char >::SizeType arg2 ;
52683   Dali::Vector< unsigned char >::ItemType *result = 0 ;
52684
52685   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52686   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52687   {
52688     try {
52689       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
52690     } catch (std::out_of_range& e) {
52691       {
52692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52693       };
52694     } catch (std::exception& e) {
52695       {
52696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52697       };
52698     } catch (Dali::DaliException e) {
52699       {
52700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52701       };
52702     } catch (...) {
52703       {
52704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52705       };
52706     }
52707   }
52708
52709   jresult = (void *)result;
52710   return jresult;
52711 }
52712
52713
52714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
52715   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52716   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
52717   Dali::Vector< unsigned char >::ItemType temp2 ;
52718
52719   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52720   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
52721   arg2 = &temp2;
52722   {
52723     try {
52724       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
52725     } catch (std::out_of_range& e) {
52726       {
52727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52728       };
52729     } catch (std::exception& e) {
52730       {
52731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52732       };
52733     } catch (Dali::DaliException e) {
52734       {
52735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52736       };
52737     } catch (...) {
52738       {
52739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52740       };
52741     }
52742   }
52743
52744 }
52745
52746
52747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
52748   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52749   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52750   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52751   Dali::Vector< unsigned char >::ItemType temp3 ;
52752
52753   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52754   arg2 = jarg2;
52755   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52756   arg3 = &temp3;
52757   {
52758     try {
52759       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52760     } catch (std::out_of_range& e) {
52761       {
52762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52763       };
52764     } catch (std::exception& e) {
52765       {
52766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52767       };
52768     } catch (Dali::DaliException e) {
52769       {
52770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52771       };
52772     } catch (...) {
52773       {
52774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52775       };
52776     }
52777   }
52778
52779
52780
52781 }
52782
52783
52784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
52785   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52786   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52787   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52788   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52789
52790   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52791   arg2 = jarg2;
52792   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52793   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
52794   {
52795     try {
52796       (arg1)->Insert(arg2,arg3,arg4);
52797     } catch (std::out_of_range& e) {
52798       {
52799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52800       };
52801     } catch (std::exception& e) {
52802       {
52803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52804       };
52805     } catch (Dali::DaliException e) {
52806       {
52807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52808       };
52809     } catch (...) {
52810       {
52811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52812       };
52813     }
52814   }
52815
52816
52817
52818 }
52819
52820
52821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
52822   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52823   Dali::Vector< unsigned char >::SizeType arg2 ;
52824
52825   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52826   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52827   {
52828     try {
52829       (arg1)->Reserve(arg2);
52830     } catch (std::out_of_range& e) {
52831       {
52832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52833       };
52834     } catch (std::exception& e) {
52835       {
52836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52837       };
52838     } catch (Dali::DaliException e) {
52839       {
52840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52841       };
52842     } catch (...) {
52843       {
52844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52845       };
52846     }
52847   }
52848
52849 }
52850
52851
52852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52853   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52854   Dali::Vector< unsigned char >::SizeType arg2 ;
52855
52856   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52857   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52858   {
52859     try {
52860       (arg1)->Resize(arg2);
52861     } catch (std::out_of_range& e) {
52862       {
52863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52864       };
52865     } catch (std::exception& e) {
52866       {
52867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52868       };
52869     } catch (Dali::DaliException e) {
52870       {
52871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52872       };
52873     } catch (...) {
52874       {
52875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52876       };
52877     }
52878   }
52879
52880 }
52881
52882
52883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
52884   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52885   Dali::Vector< unsigned char >::SizeType arg2 ;
52886   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52887   Dali::Vector< unsigned char >::ItemType temp3 ;
52888
52889   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52890   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52891   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52892   arg3 = &temp3;
52893   {
52894     try {
52895       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52896     } catch (std::out_of_range& e) {
52897       {
52898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52899       };
52900     } catch (std::exception& e) {
52901       {
52902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52903       };
52904     } catch (Dali::DaliException e) {
52905       {
52906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52907       };
52908     } catch (...) {
52909       {
52910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52911       };
52912     }
52913   }
52914
52915 }
52916
52917
52918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
52919   void * jresult ;
52920   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52921   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52922   Dali::Vector< unsigned char >::Iterator result;
52923
52924   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52925   arg2 = jarg2;
52926   {
52927     try {
52928       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
52929     } catch (std::out_of_range& e) {
52930       {
52931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52932       };
52933     } catch (std::exception& e) {
52934       {
52935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52936       };
52937     } catch (Dali::DaliException e) {
52938       {
52939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52940       };
52941     } catch (...) {
52942       {
52943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52944       };
52945     }
52946   }
52947
52948   jresult = (void *)result;
52949
52950
52951   return jresult;
52952 }
52953
52954
52955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
52956   void * jresult ;
52957   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52958   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52959   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52960   Dali::Vector< unsigned char >::Iterator result;
52961
52962   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52963   arg2 = jarg2;
52964   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52965   {
52966     try {
52967       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
52968     } catch (std::out_of_range& e) {
52969       {
52970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52971       };
52972     } catch (std::exception& e) {
52973       {
52974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52975       };
52976     } catch (Dali::DaliException e) {
52977       {
52978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52979       };
52980     } catch (...) {
52981       {
52982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52983       };
52984     }
52985   }
52986
52987   jresult = (void *)result;
52988
52989
52990   return jresult;
52991 }
52992
52993
52994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
52995   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52996   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52997
52998   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52999   arg2 = jarg2;
53000   {
53001     try {
53002       (arg1)->Remove(arg2);
53003     } catch (std::out_of_range& e) {
53004       {
53005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53006       };
53007     } catch (std::exception& e) {
53008       {
53009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53010       };
53011     } catch (Dali::DaliException e) {
53012       {
53013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53014       };
53015     } catch (...) {
53016       {
53017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53018       };
53019     }
53020   }
53021
53022
53023
53024 }
53025
53026
53027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
53028   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
53029   Dali::Vector< unsigned char > *arg2 = 0 ;
53030
53031   arg1 = (Dali::Vector< unsigned char > *)jarg1;
53032   arg2 = (Dali::Vector< unsigned char > *)jarg2;
53033   if (!arg2) {
53034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
53035     return ;
53036   }
53037   {
53038     try {
53039       (arg1)->Swap(*arg2);
53040     } catch (std::out_of_range& e) {
53041       {
53042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53043       };
53044     } catch (std::exception& e) {
53045       {
53046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53047       };
53048     } catch (Dali::DaliException e) {
53049       {
53050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53051       };
53052     } catch (...) {
53053       {
53054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53055       };
53056     }
53057   }
53058
53059 }
53060
53061
53062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
53063   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
53064
53065   arg1 = (Dali::Vector< unsigned char > *)jarg1;
53066   {
53067     try {
53068       (arg1)->Clear();
53069     } catch (std::out_of_range& e) {
53070       {
53071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53072       };
53073     } catch (std::exception& e) {
53074       {
53075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53076       };
53077     } catch (Dali::DaliException e) {
53078       {
53079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53080       };
53081     } catch (...) {
53082       {
53083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53084       };
53085     }
53086   }
53087
53088 }
53089
53090
53091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
53092   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
53093
53094   arg1 = (Dali::Vector< unsigned char > *)jarg1;
53095   {
53096     try {
53097       (arg1)->Release();
53098     } catch (std::out_of_range& e) {
53099       {
53100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53101       };
53102     } catch (std::exception& e) {
53103       {
53104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53105       };
53106     } catch (Dali::DaliException e) {
53107       {
53108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53109       };
53110     } catch (...) {
53111       {
53112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53113       };
53114     }
53115   }
53116
53117 }
53118
53119
53120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
53121   int jresult ;
53122   int result;
53123
53124   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
53125   jresult = (int)result;
53126   return jresult;
53127 }
53128
53129
53130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
53131   void * jresult ;
53132   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53133
53134   {
53135     try {
53136       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
53137     } catch (std::out_of_range& e) {
53138       {
53139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53140       };
53141     } catch (std::exception& e) {
53142       {
53143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53144       };
53145     } catch (Dali::DaliException e) {
53146       {
53147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53148       };
53149     } catch (...) {
53150       {
53151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53152       };
53153     }
53154   }
53155
53156   jresult = (void *)result;
53157   return jresult;
53158 }
53159
53160
53161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
53162   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53163
53164   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53165   {
53166     try {
53167       delete arg1;
53168     } catch (std::out_of_range& e) {
53169       {
53170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53171       };
53172     } catch (std::exception& e) {
53173       {
53174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53175       };
53176     } catch (Dali::DaliException e) {
53177       {
53178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53179       };
53180     } catch (...) {
53181       {
53182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53183       };
53184     }
53185   }
53186
53187 }
53188
53189
53190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
53191   void * jresult ;
53192   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
53193   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53194
53195   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53196   if (!arg1) {
53197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53198     return 0;
53199   }
53200   {
53201     try {
53202       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
53203     } catch (std::out_of_range& e) {
53204       {
53205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53206       };
53207     } catch (std::exception& e) {
53208       {
53209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53210       };
53211     } catch (Dali::DaliException e) {
53212       {
53213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53214       };
53215     } catch (...) {
53216       {
53217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53218       };
53219     }
53220   }
53221
53222   jresult = (void *)result;
53223   return jresult;
53224 }
53225
53226
53227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
53228   void * jresult ;
53229   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53230   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53231   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53232
53233   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53234   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53235   if (!arg2) {
53236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53237     return 0;
53238   }
53239   {
53240     try {
53241       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
53242     } catch (std::out_of_range& e) {
53243       {
53244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53245       };
53246     } catch (std::exception& e) {
53247       {
53248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53249       };
53250     } catch (Dali::DaliException e) {
53251       {
53252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53253       };
53254     } catch (...) {
53255       {
53256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53257       };
53258     }
53259   }
53260
53261   jresult = (void *)result;
53262   return jresult;
53263 }
53264
53265
53266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
53267   void * jresult ;
53268   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53269   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53270
53271   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53272   {
53273     try {
53274       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
53275     } catch (std::out_of_range& e) {
53276       {
53277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53278       };
53279     } catch (std::exception& e) {
53280       {
53281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53282       };
53283     } catch (Dali::DaliException e) {
53284       {
53285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53286       };
53287     } catch (...) {
53288       {
53289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53290       };
53291     }
53292   }
53293
53294   jresult = (void *)result;
53295   return jresult;
53296 }
53297
53298
53299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
53300   void * jresult ;
53301   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53302   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53303
53304   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53305   {
53306     try {
53307       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
53308     } catch (std::out_of_range& e) {
53309       {
53310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53311       };
53312     } catch (std::exception& e) {
53313       {
53314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53315       };
53316     } catch (Dali::DaliException e) {
53317       {
53318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53319       };
53320     } catch (...) {
53321       {
53322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53323       };
53324     }
53325   }
53326
53327   jresult = (void *)result;
53328   return jresult;
53329 }
53330
53331
53332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
53333   void * jresult ;
53334   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53335   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53336   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
53337
53338   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53339   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53340   {
53341     try {
53342       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
53343     } catch (std::out_of_range& e) {
53344       {
53345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53346       };
53347     } catch (std::exception& e) {
53348       {
53349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53350       };
53351     } catch (Dali::DaliException e) {
53352       {
53353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53354       };
53355     } catch (...) {
53356       {
53357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53358       };
53359     }
53360   }
53361
53362   jresult = (void *)result;
53363   return jresult;
53364 }
53365
53366
53367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
53368   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53369   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
53370
53371   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53372   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
53373   if (!arg2) {
53374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53375     return ;
53376   }
53377   {
53378     try {
53379       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
53380     } catch (std::out_of_range& e) {
53381       {
53382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53383       };
53384     } catch (std::exception& e) {
53385       {
53386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53387       };
53388     } catch (Dali::DaliException e) {
53389       {
53390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53391       };
53392     } catch (...) {
53393       {
53394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53395       };
53396     }
53397   }
53398
53399 }
53400
53401
53402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
53403   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53404   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53405   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53406
53407   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53408   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53409   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53410   if (!arg3) {
53411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53412     return ;
53413   }
53414   {
53415     try {
53416       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53417     } catch (std::out_of_range& e) {
53418       {
53419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53420       };
53421     } catch (std::exception& e) {
53422       {
53423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53424       };
53425     } catch (Dali::DaliException e) {
53426       {
53427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53428       };
53429     } catch (...) {
53430       {
53431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53432       };
53433     }
53434   }
53435
53436 }
53437
53438
53439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
53440   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53441   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53442   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53443   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53444
53445   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53446   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53447   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53448   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
53449   {
53450     try {
53451       (arg1)->Insert(arg2,arg3,arg4);
53452     } catch (std::out_of_range& e) {
53453       {
53454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53455       };
53456     } catch (std::exception& e) {
53457       {
53458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53459       };
53460     } catch (Dali::DaliException e) {
53461       {
53462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53463       };
53464     } catch (...) {
53465       {
53466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53467       };
53468     }
53469   }
53470
53471 }
53472
53473
53474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
53475   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53476   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53477
53478   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53479   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53480   {
53481     try {
53482       (arg1)->Reserve(arg2);
53483     } catch (std::out_of_range& e) {
53484       {
53485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53486       };
53487     } catch (std::exception& e) {
53488       {
53489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53490       };
53491     } catch (Dali::DaliException e) {
53492       {
53493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53494       };
53495     } catch (...) {
53496       {
53497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53498       };
53499     }
53500   }
53501
53502 }
53503
53504
53505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
53506   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53507   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53508
53509   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53510   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53511   {
53512     try {
53513       (arg1)->Resize(arg2);
53514     } catch (std::out_of_range& e) {
53515       {
53516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53517       };
53518     } catch (std::exception& e) {
53519       {
53520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53521       };
53522     } catch (Dali::DaliException e) {
53523       {
53524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53525       };
53526     } catch (...) {
53527       {
53528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53529       };
53530     }
53531   }
53532
53533 }
53534
53535
53536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
53537   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53538   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53539   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53540
53541   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53542   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53543   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53544   if (!arg3) {
53545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53546     return ;
53547   }
53548   {
53549     try {
53550       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53551     } catch (std::out_of_range& e) {
53552       {
53553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53554       };
53555     } catch (std::exception& e) {
53556       {
53557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53558       };
53559     } catch (Dali::DaliException e) {
53560       {
53561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53562       };
53563     } catch (...) {
53564       {
53565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53566       };
53567     }
53568   }
53569
53570 }
53571
53572
53573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
53574   void * jresult ;
53575   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53576   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53577   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53578
53579   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53580   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53581   {
53582     try {
53583       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
53584     } catch (std::out_of_range& e) {
53585       {
53586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53587       };
53588     } catch (std::exception& e) {
53589       {
53590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53591       };
53592     } catch (Dali::DaliException e) {
53593       {
53594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53595       };
53596     } catch (...) {
53597       {
53598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53599       };
53600     }
53601   }
53602
53603   jresult = (void *)result;
53604   return jresult;
53605 }
53606
53607
53608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
53609   void * jresult ;
53610   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53611   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53612   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53613   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53614
53615   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53616   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53617   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53618   {
53619     try {
53620       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
53621     } catch (std::out_of_range& e) {
53622       {
53623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53624       };
53625     } catch (std::exception& e) {
53626       {
53627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53628       };
53629     } catch (Dali::DaliException e) {
53630       {
53631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53632       };
53633     } catch (...) {
53634       {
53635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53636       };
53637     }
53638   }
53639
53640   jresult = (void *)result;
53641   return jresult;
53642 }
53643
53644
53645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
53646   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53647   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53648
53649   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53650   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53651   {
53652     try {
53653       (arg1)->Remove(arg2);
53654     } catch (std::out_of_range& e) {
53655       {
53656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53657       };
53658     } catch (std::exception& e) {
53659       {
53660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53661       };
53662     } catch (Dali::DaliException e) {
53663       {
53664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53665       };
53666     } catch (...) {
53667       {
53668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53669       };
53670     }
53671   }
53672
53673 }
53674
53675
53676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
53677   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53678   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53679
53680   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53681   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53682   if (!arg2) {
53683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
53684     return ;
53685   }
53686   {
53687     try {
53688       (arg1)->Swap(*arg2);
53689     } catch (std::out_of_range& e) {
53690       {
53691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53692       };
53693     } catch (std::exception& e) {
53694       {
53695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53696       };
53697     } catch (Dali::DaliException e) {
53698       {
53699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53700       };
53701     } catch (...) {
53702       {
53703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53704       };
53705     }
53706   }
53707
53708 }
53709
53710
53711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
53712   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53713
53714   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53715   {
53716     try {
53717       (arg1)->Clear();
53718     } catch (std::out_of_range& e) {
53719       {
53720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53721       };
53722     } catch (std::exception& e) {
53723       {
53724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53725       };
53726     } catch (Dali::DaliException e) {
53727       {
53728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53729       };
53730     } catch (...) {
53731       {
53732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53733       };
53734     }
53735   }
53736
53737 }
53738
53739
53740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
53741   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53742
53743   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53744   {
53745     try {
53746       (arg1)->Release();
53747     } catch (std::out_of_range& e) {
53748       {
53749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53750       };
53751     } catch (std::exception& e) {
53752       {
53753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53754       };
53755     } catch (Dali::DaliException e) {
53756       {
53757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53758       };
53759     } catch (...) {
53760       {
53761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53762       };
53763     }
53764   }
53765
53766 }
53767
53768
53769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
53770   void * jresult ;
53771   Dali::Signal< void () > *result = 0 ;
53772
53773   {
53774     try {
53775       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
53776     } catch (std::out_of_range& e) {
53777       {
53778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53779       };
53780     } catch (std::exception& e) {
53781       {
53782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53783       };
53784     } catch (Dali::DaliException e) {
53785       {
53786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53787       };
53788     } catch (...) {
53789       {
53790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53791       };
53792     }
53793   }
53794
53795   jresult = (void *)result;
53796   return jresult;
53797 }
53798
53799
53800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
53801   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53802
53803   arg1 = (Dali::Signal< void () > *)jarg1;
53804   {
53805     try {
53806       delete arg1;
53807     } catch (std::out_of_range& e) {
53808       {
53809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53810       };
53811     } catch (std::exception& e) {
53812       {
53813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53814       };
53815     } catch (Dali::DaliException e) {
53816       {
53817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53818       };
53819     } catch (...) {
53820       {
53821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53822       };
53823     }
53824   }
53825
53826 }
53827
53828
53829 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
53830   unsigned int jresult ;
53831   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53832   bool result;
53833
53834   arg1 = (Dali::Signal< void () > *)jarg1;
53835   {
53836     try {
53837       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
53838     } catch (std::out_of_range& e) {
53839       {
53840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53841       };
53842     } catch (std::exception& e) {
53843       {
53844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53845       };
53846     } catch (Dali::DaliException e) {
53847       {
53848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53849       };
53850     } catch (...) {
53851       {
53852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53853       };
53854     }
53855   }
53856
53857   jresult = result;
53858   return jresult;
53859 }
53860
53861
53862 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
53863   unsigned long jresult ;
53864   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53865   std::size_t result;
53866
53867   arg1 = (Dali::Signal< void () > *)jarg1;
53868   {
53869     try {
53870       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
53871     } catch (std::out_of_range& e) {
53872       {
53873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53874       };
53875     } catch (std::exception& e) {
53876       {
53877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53878       };
53879     } catch (Dali::DaliException e) {
53880       {
53881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53882       };
53883     } catch (...) {
53884       {
53885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53886       };
53887     }
53888   }
53889
53890   jresult = (unsigned long)result;
53891   return jresult;
53892 }
53893
53894
53895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
53896   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53897   void (*arg2)() = (void (*)()) 0 ;
53898
53899   arg1 = (Dali::Signal< void () > *)jarg1;
53900   arg2 = (void (*)())jarg2;
53901   {
53902     try {
53903       (arg1)->Connect(arg2);
53904     } catch (std::out_of_range& e) {
53905       {
53906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53907       };
53908     } catch (std::exception& e) {
53909       {
53910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53911       };
53912     } catch (Dali::DaliException e) {
53913       {
53914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53915       };
53916     } catch (...) {
53917       {
53918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53919       };
53920     }
53921   }
53922
53923 }
53924
53925
53926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
53927   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53928   void (*arg2)() = (void (*)()) 0 ;
53929
53930   arg1 = (Dali::Signal< void () > *)jarg1;
53931   arg2 = (void (*)())jarg2;
53932   {
53933     try {
53934       (arg1)->Disconnect(arg2);
53935     } catch (std::out_of_range& e) {
53936       {
53937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53938       };
53939     } catch (std::exception& e) {
53940       {
53941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53942       };
53943     } catch (Dali::DaliException e) {
53944       {
53945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53946       };
53947     } catch (...) {
53948       {
53949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53950       };
53951     }
53952   }
53953
53954 }
53955
53956
53957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
53958   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53959   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
53960   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
53961
53962   arg1 = (Dali::Signal< void () > *)jarg1;
53963   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
53964   arg3 = (Dali::FunctorDelegate *)jarg3;
53965   {
53966     try {
53967       (arg1)->Connect(arg2,arg3);
53968     } catch (std::out_of_range& e) {
53969       {
53970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53971       };
53972     } catch (std::exception& e) {
53973       {
53974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53975       };
53976     } catch (Dali::DaliException e) {
53977       {
53978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53979       };
53980     } catch (...) {
53981       {
53982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53983       };
53984     }
53985   }
53986
53987 }
53988
53989
53990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
53991   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53992
53993   arg1 = (Dali::Signal< void () > *)jarg1;
53994   {
53995     try {
53996       (arg1)->Emit();
53997     } catch (std::out_of_range& e) {
53998       {
53999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54000       };
54001     } catch (std::exception& e) {
54002       {
54003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54004       };
54005     } catch (Dali::DaliException e) {
54006       {
54007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54008       };
54009     } catch (...) {
54010       {
54011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54012       };
54013     }
54014   }
54015
54016 }
54017
54018
54019 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
54020   unsigned int jresult ;
54021   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54022   bool result;
54023
54024   arg1 = (Dali::Signal< void (float) > *)jarg1;
54025   {
54026     try {
54027       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
54028     } catch (std::out_of_range& e) {
54029       {
54030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54031       };
54032     } catch (std::exception& e) {
54033       {
54034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54035       };
54036     } catch (Dali::DaliException e) {
54037       {
54038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54039       };
54040     } catch (...) {
54041       {
54042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54043       };
54044     }
54045   }
54046
54047   jresult = result;
54048   return jresult;
54049 }
54050
54051
54052 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
54053   unsigned long jresult ;
54054   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54055   std::size_t result;
54056
54057   arg1 = (Dali::Signal< void (float) > *)jarg1;
54058   {
54059     try {
54060       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
54061     } catch (std::out_of_range& e) {
54062       {
54063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54064       };
54065     } catch (std::exception& e) {
54066       {
54067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54068       };
54069     } catch (Dali::DaliException e) {
54070       {
54071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54072       };
54073     } catch (...) {
54074       {
54075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54076       };
54077     }
54078   }
54079
54080   jresult = (unsigned long)result;
54081   return jresult;
54082 }
54083
54084
54085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
54086   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54087   void (*arg2)(float) = (void (*)(float)) 0 ;
54088
54089   arg1 = (Dali::Signal< void (float) > *)jarg1;
54090   arg2 = (void (*)(float))jarg2;
54091   {
54092     try {
54093       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
54094     } catch (std::out_of_range& e) {
54095       {
54096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54097       };
54098     } catch (std::exception& e) {
54099       {
54100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54101       };
54102     } catch (Dali::DaliException e) {
54103       {
54104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54105       };
54106     } catch (...) {
54107       {
54108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54109       };
54110     }
54111   }
54112
54113 }
54114
54115
54116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
54117   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54118   void (*arg2)(float) = (void (*)(float)) 0 ;
54119
54120   arg1 = (Dali::Signal< void (float) > *)jarg1;
54121   arg2 = (void (*)(float))jarg2;
54122   {
54123     try {
54124       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
54125     } catch (std::out_of_range& e) {
54126       {
54127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54128       };
54129     } catch (std::exception& e) {
54130       {
54131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54132       };
54133     } catch (Dali::DaliException e) {
54134       {
54135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54136       };
54137     } catch (...) {
54138       {
54139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54140       };
54141     }
54142   }
54143
54144 }
54145
54146
54147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
54148   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54149   float arg2 ;
54150
54151   arg1 = (Dali::Signal< void (float) > *)jarg1;
54152   arg2 = (float)jarg2;
54153   {
54154     try {
54155       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
54156     } catch (std::out_of_range& e) {
54157       {
54158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54159       };
54160     } catch (std::exception& e) {
54161       {
54162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54163       };
54164     } catch (Dali::DaliException e) {
54165       {
54166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54167       };
54168     } catch (...) {
54169       {
54170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54171       };
54172     }
54173   }
54174
54175 }
54176
54177
54178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
54179   void * jresult ;
54180   Dali::Signal< void (float) > *result = 0 ;
54181
54182   {
54183     try {
54184       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
54185     } catch (std::out_of_range& e) {
54186       {
54187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54188       };
54189     } catch (std::exception& e) {
54190       {
54191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54192       };
54193     } catch (Dali::DaliException e) {
54194       {
54195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54196       };
54197     } catch (...) {
54198       {
54199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54200       };
54201     }
54202   }
54203
54204   jresult = (void *)result;
54205   return jresult;
54206 }
54207
54208
54209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
54210   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54211
54212   arg1 = (Dali::Signal< void (float) > *)jarg1;
54213   {
54214     try {
54215       delete arg1;
54216     } catch (std::out_of_range& e) {
54217       {
54218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54219       };
54220     } catch (std::exception& e) {
54221       {
54222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54223       };
54224     } catch (Dali::DaliException e) {
54225       {
54226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54227       };
54228     } catch (...) {
54229       {
54230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54231       };
54232     }
54233   }
54234
54235 }
54236
54237
54238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
54239   unsigned int jresult ;
54240   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54241   bool result;
54242
54243   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54244   {
54245     try {
54246       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54247     } catch (std::out_of_range& e) {
54248       {
54249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54250       };
54251     } catch (std::exception& e) {
54252       {
54253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54254       };
54255     } catch (Dali::DaliException e) {
54256       {
54257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54258       };
54259     } catch (...) {
54260       {
54261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54262       };
54263     }
54264   }
54265
54266   jresult = result;
54267   return jresult;
54268 }
54269
54270
54271 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
54272   unsigned long jresult ;
54273   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54274   std::size_t result;
54275
54276   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54277   {
54278     try {
54279       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54280     } catch (std::out_of_range& e) {
54281       {
54282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54283       };
54284     } catch (std::exception& e) {
54285       {
54286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54287       };
54288     } catch (Dali::DaliException e) {
54289       {
54290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54291       };
54292     } catch (...) {
54293       {
54294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54295       };
54296     }
54297   }
54298
54299   jresult = (unsigned long)result;
54300   return jresult;
54301 }
54302
54303
54304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
54305   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54306   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54307
54308   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54309   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54310   {
54311     try {
54312       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
54313     } catch (std::out_of_range& e) {
54314       {
54315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54316       };
54317     } catch (std::exception& e) {
54318       {
54319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54320       };
54321     } catch (Dali::DaliException e) {
54322       {
54323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54324       };
54325     } catch (...) {
54326       {
54327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54328       };
54329     }
54330   }
54331
54332 }
54333
54334
54335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
54336   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54337   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54338
54339   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54340   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54341   {
54342     try {
54343       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
54344     } catch (std::out_of_range& e) {
54345       {
54346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54347       };
54348     } catch (std::exception& e) {
54349       {
54350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54351       };
54352     } catch (Dali::DaliException e) {
54353       {
54354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54355       };
54356     } catch (...) {
54357       {
54358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54359       };
54360     }
54361   }
54362
54363 }
54364
54365
54366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
54367   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54368   Dali::BaseHandle arg2 ;
54369   Dali::BaseHandle *argp2 ;
54370
54371   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54372   argp2 = (Dali::BaseHandle *)jarg2;
54373   if (!argp2) {
54374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54375     return ;
54376   }
54377   arg2 = *argp2;
54378   {
54379     try {
54380       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
54381     } catch (std::out_of_range& e) {
54382       {
54383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54384       };
54385     } catch (std::exception& e) {
54386       {
54387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54388       };
54389     } catch (Dali::DaliException e) {
54390       {
54391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54392       };
54393     } catch (...) {
54394       {
54395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54396       };
54397     }
54398   }
54399
54400 }
54401
54402
54403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
54404   void * jresult ;
54405   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
54406
54407   {
54408     try {
54409       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
54410     } catch (std::out_of_range& e) {
54411       {
54412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54413       };
54414     } catch (std::exception& e) {
54415       {
54416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54417       };
54418     } catch (Dali::DaliException e) {
54419       {
54420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54421       };
54422     } catch (...) {
54423       {
54424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54425       };
54426     }
54427   }
54428
54429   jresult = (void *)result;
54430   return jresult;
54431 }
54432
54433
54434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
54435   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54436
54437   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54438   {
54439     try {
54440       delete arg1;
54441     } catch (std::out_of_range& e) {
54442       {
54443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54444       };
54445     } catch (std::exception& e) {
54446       {
54447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54448       };
54449     } catch (Dali::DaliException e) {
54450       {
54451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54452       };
54453     } catch (...) {
54454       {
54455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54456       };
54457     }
54458   }
54459
54460 }
54461
54462
54463 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
54464   unsigned int jresult ;
54465   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54466   bool result;
54467
54468   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54469   {
54470     try {
54471       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54472     } catch (std::out_of_range& e) {
54473       {
54474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54475       };
54476     } catch (std::exception& e) {
54477       {
54478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54479       };
54480     } catch (Dali::DaliException e) {
54481       {
54482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54483       };
54484     } catch (...) {
54485       {
54486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54487       };
54488     }
54489   }
54490
54491   jresult = result;
54492   return jresult;
54493 }
54494
54495
54496 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
54497   unsigned long jresult ;
54498   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54499   std::size_t result;
54500
54501   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54502   {
54503     try {
54504       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54505     } catch (std::out_of_range& e) {
54506       {
54507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54508       };
54509     } catch (std::exception& e) {
54510       {
54511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54512       };
54513     } catch (Dali::DaliException e) {
54514       {
54515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54516       };
54517     } catch (...) {
54518       {
54519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54520       };
54521     }
54522   }
54523
54524   jresult = (unsigned long)result;
54525   return jresult;
54526 }
54527
54528
54529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
54530   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54531   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54532
54533   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54534   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54535   {
54536     try {
54537       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
54538     } catch (std::out_of_range& e) {
54539       {
54540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54541       };
54542     } catch (std::exception& e) {
54543       {
54544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54545       };
54546     } catch (Dali::DaliException e) {
54547       {
54548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54549       };
54550     } catch (...) {
54551       {
54552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54553       };
54554     }
54555   }
54556
54557 }
54558
54559
54560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
54561   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54562   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54563
54564   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54565   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54566   {
54567     try {
54568       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
54569     } catch (std::out_of_range& e) {
54570       {
54571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54572       };
54573     } catch (std::exception& e) {
54574       {
54575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54576       };
54577     } catch (Dali::DaliException e) {
54578       {
54579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54580       };
54581     } catch (...) {
54582       {
54583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54584       };
54585     }
54586   }
54587
54588 }
54589
54590
54591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
54592   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54593   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
54594
54595   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54596   arg2 = (Dali::RefObject *)jarg2;
54597   {
54598     try {
54599       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
54600     } catch (std::out_of_range& e) {
54601       {
54602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54603       };
54604     } catch (std::exception& e) {
54605       {
54606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54607       };
54608     } catch (Dali::DaliException e) {
54609       {
54610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54611       };
54612     } catch (...) {
54613       {
54614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54615       };
54616     }
54617   }
54618
54619 }
54620
54621
54622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
54623   void * jresult ;
54624   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
54625
54626   {
54627     try {
54628       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
54629     } catch (std::out_of_range& e) {
54630       {
54631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54632       };
54633     } catch (std::exception& e) {
54634       {
54635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54636       };
54637     } catch (Dali::DaliException e) {
54638       {
54639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54640       };
54641     } catch (...) {
54642       {
54643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54644       };
54645     }
54646   }
54647
54648   jresult = (void *)result;
54649   return jresult;
54650 }
54651
54652
54653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
54654   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54655
54656   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54657   {
54658     try {
54659       delete arg1;
54660     } catch (std::out_of_range& e) {
54661       {
54662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54663       };
54664     } catch (std::exception& e) {
54665       {
54666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54667       };
54668     } catch (Dali::DaliException e) {
54669       {
54670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54671       };
54672     } catch (...) {
54673       {
54674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54675       };
54676     }
54677   }
54678
54679 }
54680
54681
54682 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
54683   unsigned int jresult ;
54684   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54685   bool result;
54686
54687   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54688   {
54689     try {
54690       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54691     } catch (std::out_of_range& e) {
54692       {
54693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54694       };
54695     } catch (std::exception& e) {
54696       {
54697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54698       };
54699     } catch (Dali::DaliException e) {
54700       {
54701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54702       };
54703     } catch (...) {
54704       {
54705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54706       };
54707     }
54708   }
54709
54710   jresult = result;
54711   return jresult;
54712 }
54713
54714
54715 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
54716   unsigned long jresult ;
54717   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54718   std::size_t result;
54719
54720   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54721   {
54722     try {
54723       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54724     } catch (std::out_of_range& e) {
54725       {
54726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54727       };
54728     } catch (std::exception& e) {
54729       {
54730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54731       };
54732     } catch (Dali::DaliException e) {
54733       {
54734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54735       };
54736     } catch (...) {
54737       {
54738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54739       };
54740     }
54741   }
54742
54743   jresult = (unsigned long)result;
54744   return jresult;
54745 }
54746
54747
54748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
54749   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54750   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54751
54752   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54753   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54754   {
54755     try {
54756       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
54757     } catch (std::out_of_range& e) {
54758       {
54759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54760       };
54761     } catch (std::exception& e) {
54762       {
54763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54764       };
54765     } catch (Dali::DaliException e) {
54766       {
54767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54768       };
54769     } catch (...) {
54770       {
54771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54772       };
54773     }
54774   }
54775
54776 }
54777
54778
54779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
54780   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54781   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54782
54783   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54784   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54785   {
54786     try {
54787       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
54788     } catch (std::out_of_range& e) {
54789       {
54790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54791       };
54792     } catch (std::exception& e) {
54793       {
54794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54795       };
54796     } catch (Dali::DaliException e) {
54797       {
54798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54799       };
54800     } catch (...) {
54801       {
54802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54803       };
54804     }
54805   }
54806
54807 }
54808
54809
54810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
54811   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54812   Dali::PropertyNotification *arg2 = 0 ;
54813
54814   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54815   arg2 = (Dali::PropertyNotification *)jarg2;
54816   if (!arg2) {
54817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
54818     return ;
54819   }
54820   {
54821     try {
54822       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
54823     } catch (std::out_of_range& e) {
54824       {
54825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54826       };
54827     } catch (std::exception& e) {
54828       {
54829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54830       };
54831     } catch (Dali::DaliException e) {
54832       {
54833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54834       };
54835     } catch (...) {
54836       {
54837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54838       };
54839     }
54840   }
54841
54842 }
54843
54844
54845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
54846   void * jresult ;
54847   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
54848
54849   {
54850     try {
54851       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
54852     } catch (std::out_of_range& e) {
54853       {
54854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54855       };
54856     } catch (std::exception& e) {
54857       {
54858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54859       };
54860     } catch (Dali::DaliException e) {
54861       {
54862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54863       };
54864     } catch (...) {
54865       {
54866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54867       };
54868     }
54869   }
54870
54871   jresult = (void *)result;
54872   return jresult;
54873 }
54874
54875
54876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
54877   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54878
54879   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54880   {
54881     try {
54882       delete arg1;
54883     } catch (std::out_of_range& e) {
54884       {
54885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54886       };
54887     } catch (std::exception& e) {
54888       {
54889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54890       };
54891     } catch (Dali::DaliException e) {
54892       {
54893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54894       };
54895     } catch (...) {
54896       {
54897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54898       };
54899     }
54900   }
54901
54902 }
54903
54904
54905 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
54906   unsigned int jresult ;
54907   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54908   bool result;
54909
54910   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54911   {
54912     try {
54913       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
54914     } catch (std::out_of_range& e) {
54915       {
54916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54917       };
54918     } catch (std::exception& e) {
54919       {
54920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54921       };
54922     } catch (Dali::DaliException e) {
54923       {
54924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54925       };
54926     } catch (...) {
54927       {
54928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54929       };
54930     }
54931   }
54932
54933   jresult = result;
54934   return jresult;
54935 }
54936
54937
54938 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
54939   unsigned long jresult ;
54940   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54941   std::size_t result;
54942
54943   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54944   {
54945     try {
54946       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
54947     } catch (std::out_of_range& e) {
54948       {
54949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54950       };
54951     } catch (std::exception& e) {
54952       {
54953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54954       };
54955     } catch (Dali::DaliException e) {
54956       {
54957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54958       };
54959     } catch (...) {
54960       {
54961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54962       };
54963     }
54964   }
54965
54966   jresult = (unsigned long)result;
54967   return jresult;
54968 }
54969
54970
54971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
54972   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54973   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54974
54975   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54976   arg2 = (void (*)(Dali::Image))jarg2;
54977   {
54978     try {
54979       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
54980     } catch (std::out_of_range& e) {
54981       {
54982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54983       };
54984     } catch (std::exception& e) {
54985       {
54986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54987       };
54988     } catch (Dali::DaliException e) {
54989       {
54990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54991       };
54992     } catch (...) {
54993       {
54994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54995       };
54996     }
54997   }
54998
54999 }
55000
55001
55002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
55003   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
55004   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
55005
55006   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
55007   arg2 = (void (*)(Dali::Image))jarg2;
55008   {
55009     try {
55010       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
55011     } catch (std::out_of_range& e) {
55012       {
55013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55014       };
55015     } catch (std::exception& e) {
55016       {
55017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55018       };
55019     } catch (Dali::DaliException e) {
55020       {
55021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55022       };
55023     } catch (...) {
55024       {
55025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55026       };
55027     }
55028   }
55029
55030 }
55031
55032
55033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
55034   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
55035   Dali::Image arg2 ;
55036   Dali::Image *argp2 ;
55037
55038   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
55039   argp2 = (Dali::Image *)jarg2;
55040   if (!argp2) {
55041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
55042     return ;
55043   }
55044   arg2 = *argp2;
55045   {
55046     try {
55047       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
55048     } catch (std::out_of_range& e) {
55049       {
55050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55051       };
55052     } catch (std::exception& e) {
55053       {
55054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55055       };
55056     } catch (Dali::DaliException e) {
55057       {
55058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55059       };
55060     } catch (...) {
55061       {
55062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55063       };
55064     }
55065   }
55066
55067 }
55068
55069
55070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
55071   void * jresult ;
55072   Dali::Signal< void (Dali::Image) > *result = 0 ;
55073
55074   {
55075     try {
55076       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
55077     } catch (std::out_of_range& e) {
55078       {
55079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55080       };
55081     } catch (std::exception& e) {
55082       {
55083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55084       };
55085     } catch (Dali::DaliException e) {
55086       {
55087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55088       };
55089     } catch (...) {
55090       {
55091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55092       };
55093     }
55094   }
55095
55096   jresult = (void *)result;
55097   return jresult;
55098 }
55099
55100
55101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
55102   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
55103
55104   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
55105   {
55106     try {
55107       delete arg1;
55108     } catch (std::out_of_range& e) {
55109       {
55110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55111       };
55112     } catch (std::exception& e) {
55113       {
55114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55115       };
55116     } catch (Dali::DaliException e) {
55117       {
55118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55119       };
55120     } catch (...) {
55121       {
55122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55123       };
55124     }
55125   }
55126
55127 }
55128
55129
55130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
55131   void * jresult ;
55132   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
55133
55134   {
55135     try {
55136       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
55137     } catch (std::out_of_range& e) {
55138       {
55139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55140       };
55141     } catch (std::exception& e) {
55142       {
55143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55144       };
55145     } catch (Dali::DaliException e) {
55146       {
55147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55148       };
55149     } catch (...) {
55150       {
55151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55152       };
55153     }
55154   }
55155
55156   jresult = (void *)result;
55157   return jresult;
55158 }
55159
55160
55161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
55162   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
55163
55164   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
55165   {
55166     try {
55167       delete arg1;
55168     } catch (std::out_of_range& e) {
55169       {
55170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55171       };
55172     } catch (std::exception& e) {
55173       {
55174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55175       };
55176     } catch (Dali::DaliException e) {
55177       {
55178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55179       };
55180     } catch (...) {
55181       {
55182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55183       };
55184     }
55185   }
55186
55187 }
55188
55189
55190 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
55191   unsigned int jresult ;
55192   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55193   bool result;
55194
55195   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55196   {
55197     try {
55198       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);
55199     } catch (std::out_of_range& e) {
55200       {
55201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55202       };
55203     } catch (std::exception& e) {
55204       {
55205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55206       };
55207     } catch (Dali::DaliException e) {
55208       {
55209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55210       };
55211     } catch (...) {
55212       {
55213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55214       };
55215     }
55216   }
55217
55218   jresult = result;
55219   return jresult;
55220 }
55221
55222
55223 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
55224   unsigned long jresult ;
55225   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55226   std::size_t result;
55227
55228   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55229   {
55230     try {
55231       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);
55232     } catch (std::out_of_range& e) {
55233       {
55234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55235       };
55236     } catch (std::exception& e) {
55237       {
55238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55239       };
55240     } catch (Dali::DaliException e) {
55241       {
55242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55243       };
55244     } catch (...) {
55245       {
55246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55247       };
55248     }
55249   }
55250
55251   jresult = (unsigned long)result;
55252   return jresult;
55253 }
55254
55255
55256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
55257   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55258   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55259
55260   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55261   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55262   {
55263     try {
55264       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55265     } catch (std::out_of_range& e) {
55266       {
55267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55268       };
55269     } catch (std::exception& e) {
55270       {
55271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55272       };
55273     } catch (Dali::DaliException e) {
55274       {
55275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55276       };
55277     } catch (...) {
55278       {
55279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55280       };
55281     }
55282   }
55283
55284 }
55285
55286
55287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
55288   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55289   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55290
55291   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55292   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55293   {
55294     try {
55295       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55296     } catch (std::out_of_range& e) {
55297       {
55298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55299       };
55300     } catch (std::exception& e) {
55301       {
55302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55303       };
55304     } catch (Dali::DaliException e) {
55305       {
55306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55307       };
55308     } catch (...) {
55309       {
55310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55311       };
55312     }
55313   }
55314
55315 }
55316
55317
55318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55319   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55320   Dali::Actor arg2 ;
55321   Dali::LongPressGesture *arg3 = 0 ;
55322   Dali::Actor *argp2 ;
55323
55324   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55325   argp2 = (Dali::Actor *)jarg2;
55326   if (!argp2) {
55327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55328     return ;
55329   }
55330   arg2 = *argp2;
55331   arg3 = (Dali::LongPressGesture *)jarg3;
55332   if (!arg3) {
55333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
55334     return ;
55335   }
55336   {
55337     try {
55338       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
55339     } catch (std::out_of_range& e) {
55340       {
55341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55342       };
55343     } catch (std::exception& e) {
55344       {
55345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55346       };
55347     } catch (Dali::DaliException e) {
55348       {
55349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55350       };
55351     } catch (...) {
55352       {
55353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55354       };
55355     }
55356   }
55357
55358 }
55359
55360
55361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
55362   void * jresult ;
55363   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
55364
55365   {
55366     try {
55367       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
55368     } catch (std::out_of_range& e) {
55369       {
55370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55371       };
55372     } catch (std::exception& e) {
55373       {
55374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55375       };
55376     } catch (Dali::DaliException e) {
55377       {
55378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55379       };
55380     } catch (...) {
55381       {
55382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55383       };
55384     }
55385   }
55386
55387   jresult = (void *)result;
55388   return jresult;
55389 }
55390
55391
55392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
55393   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55394
55395   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55396   {
55397     try {
55398       delete arg1;
55399     } catch (std::out_of_range& e) {
55400       {
55401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55402       };
55403     } catch (std::exception& e) {
55404       {
55405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55406       };
55407     } catch (Dali::DaliException e) {
55408       {
55409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55410       };
55411     } catch (...) {
55412       {
55413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55414       };
55415     }
55416   }
55417
55418 }
55419
55420
55421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
55422   unsigned int jresult ;
55423   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55424   bool result;
55425
55426   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55427   {
55428     try {
55429       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);
55430     } catch (std::out_of_range& e) {
55431       {
55432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55433       };
55434     } catch (std::exception& e) {
55435       {
55436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55437       };
55438     } catch (Dali::DaliException e) {
55439       {
55440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55441       };
55442     } catch (...) {
55443       {
55444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55445       };
55446     }
55447   }
55448
55449   jresult = result;
55450   return jresult;
55451 }
55452
55453
55454 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
55455   unsigned long jresult ;
55456   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55457   std::size_t result;
55458
55459   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55460   {
55461     try {
55462       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);
55463     } catch (std::out_of_range& e) {
55464       {
55465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55466       };
55467     } catch (std::exception& e) {
55468       {
55469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55470       };
55471     } catch (Dali::DaliException e) {
55472       {
55473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55474       };
55475     } catch (...) {
55476       {
55477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55478       };
55479     }
55480   }
55481
55482   jresult = (unsigned long)result;
55483   return jresult;
55484 }
55485
55486
55487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
55488   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55489   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55490
55491   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55492   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55493   {
55494     try {
55495       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55496     } catch (std::out_of_range& e) {
55497       {
55498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55499       };
55500     } catch (std::exception& e) {
55501       {
55502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55503       };
55504     } catch (Dali::DaliException e) {
55505       {
55506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55507       };
55508     } catch (...) {
55509       {
55510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55511       };
55512     }
55513   }
55514
55515 }
55516
55517
55518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
55519   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55520   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55521
55522   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55523   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55524   {
55525     try {
55526       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55527     } catch (std::out_of_range& e) {
55528       {
55529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55530       };
55531     } catch (std::exception& e) {
55532       {
55533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55534       };
55535     } catch (Dali::DaliException e) {
55536       {
55537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55538       };
55539     } catch (...) {
55540       {
55541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55542       };
55543     }
55544   }
55545
55546 }
55547
55548
55549 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55550   unsigned int jresult ;
55551   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55552   Dali::Actor arg2 ;
55553   Dali::TouchData *arg3 = 0 ;
55554   Dali::Actor *argp2 ;
55555   bool result;
55556
55557   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55558   argp2 = (Dali::Actor *)jarg2;
55559   if (!argp2) {
55560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55561     return 0;
55562   }
55563   arg2 = *argp2;
55564   arg3 = (Dali::TouchData *)jarg3;
55565   if (!arg3) {
55566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
55567     return 0;
55568   }
55569   {
55570     try {
55571       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
55572     } catch (std::out_of_range& e) {
55573       {
55574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55575       };
55576     } catch (std::exception& e) {
55577       {
55578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55579       };
55580     } catch (Dali::DaliException e) {
55581       {
55582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55583       };
55584     } catch (...) {
55585       {
55586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55587       };
55588     }
55589   }
55590
55591   jresult = result;
55592   return jresult;
55593 }
55594
55595
55596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
55597   void * jresult ;
55598   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
55599
55600   {
55601     try {
55602       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
55603     } catch (std::out_of_range& e) {
55604       {
55605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55606       };
55607     } catch (std::exception& e) {
55608       {
55609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55610       };
55611     } catch (Dali::DaliException e) {
55612       {
55613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55614       };
55615     } catch (...) {
55616       {
55617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55618       };
55619     }
55620   }
55621
55622   jresult = (void *)result;
55623   return jresult;
55624 }
55625
55626
55627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
55628   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55629
55630   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55631   {
55632     try {
55633       delete arg1;
55634     } catch (std::out_of_range& e) {
55635       {
55636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55637       };
55638     } catch (std::exception& e) {
55639       {
55640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55641       };
55642     } catch (Dali::DaliException e) {
55643       {
55644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55645       };
55646     } catch (...) {
55647       {
55648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55649       };
55650     }
55651   }
55652
55653 }
55654
55655
55656 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
55657   unsigned int jresult ;
55658   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55659   bool result;
55660
55661   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55662   {
55663     try {
55664       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);
55665     } catch (std::out_of_range& e) {
55666       {
55667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55668       };
55669     } catch (std::exception& e) {
55670       {
55671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55672       };
55673     } catch (Dali::DaliException e) {
55674       {
55675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55676       };
55677     } catch (...) {
55678       {
55679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55680       };
55681     }
55682   }
55683
55684   jresult = result;
55685   return jresult;
55686 }
55687
55688
55689 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
55690   unsigned long jresult ;
55691   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55692   std::size_t result;
55693
55694   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55695   {
55696     try {
55697       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);
55698     } catch (std::out_of_range& e) {
55699       {
55700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55701       };
55702     } catch (std::exception& e) {
55703       {
55704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55705       };
55706     } catch (Dali::DaliException e) {
55707       {
55708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55709       };
55710     } catch (...) {
55711       {
55712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55713       };
55714     }
55715   }
55716
55717   jresult = (unsigned long)result;
55718   return jresult;
55719 }
55720
55721
55722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
55723   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55724   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55725
55726   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55727   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55728   {
55729     try {
55730       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55731     } catch (std::out_of_range& e) {
55732       {
55733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55734       };
55735     } catch (std::exception& e) {
55736       {
55737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55738       };
55739     } catch (Dali::DaliException e) {
55740       {
55741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55742       };
55743     } catch (...) {
55744       {
55745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55746       };
55747     }
55748   }
55749
55750 }
55751
55752
55753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
55754   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55755   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55756
55757   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55758   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55759   {
55760     try {
55761       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55762     } catch (std::out_of_range& e) {
55763       {
55764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55765       };
55766     } catch (std::exception& e) {
55767       {
55768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55769       };
55770     } catch (Dali::DaliException e) {
55771       {
55772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55773       };
55774     } catch (...) {
55775       {
55776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55777       };
55778     }
55779   }
55780
55781 }
55782
55783
55784 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55785   unsigned int jresult ;
55786   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55787   Dali::Actor arg2 ;
55788   Dali::HoverEvent *arg3 = 0 ;
55789   Dali::Actor *argp2 ;
55790   bool result;
55791
55792   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55793   argp2 = (Dali::Actor *)jarg2;
55794   if (!argp2) {
55795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55796     return 0;
55797   }
55798   arg2 = *argp2;
55799   arg3 = (Dali::HoverEvent *)jarg3;
55800   if (!arg3) {
55801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
55802     return 0;
55803   }
55804   {
55805     try {
55806       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
55807     } catch (std::out_of_range& e) {
55808       {
55809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55810       };
55811     } catch (std::exception& e) {
55812       {
55813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55814       };
55815     } catch (Dali::DaliException e) {
55816       {
55817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55818       };
55819     } catch (...) {
55820       {
55821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55822       };
55823     }
55824   }
55825
55826   jresult = result;
55827   return jresult;
55828 }
55829
55830
55831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
55832   void * jresult ;
55833   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
55834
55835   {
55836     try {
55837       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
55838     } catch (std::out_of_range& e) {
55839       {
55840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55841       };
55842     } catch (std::exception& e) {
55843       {
55844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55845       };
55846     } catch (Dali::DaliException e) {
55847       {
55848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55849       };
55850     } catch (...) {
55851       {
55852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55853       };
55854     }
55855   }
55856
55857   jresult = (void *)result;
55858   return jresult;
55859 }
55860
55861
55862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
55863   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55864
55865   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55866   {
55867     try {
55868       delete arg1;
55869     } catch (std::out_of_range& e) {
55870       {
55871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55872       };
55873     } catch (std::exception& e) {
55874       {
55875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55876       };
55877     } catch (Dali::DaliException e) {
55878       {
55879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55880       };
55881     } catch (...) {
55882       {
55883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55884       };
55885     }
55886   }
55887
55888 }
55889
55890
55891 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
55892   unsigned int jresult ;
55893   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55894   bool result;
55895
55896   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55897   {
55898     try {
55899       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);
55900     } catch (std::out_of_range& e) {
55901       {
55902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55903       };
55904     } catch (std::exception& e) {
55905       {
55906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55907       };
55908     } catch (Dali::DaliException e) {
55909       {
55910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55911       };
55912     } catch (...) {
55913       {
55914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55915       };
55916     }
55917   }
55918
55919   jresult = result;
55920   return jresult;
55921 }
55922
55923
55924 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
55925   unsigned long jresult ;
55926   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55927   std::size_t result;
55928
55929   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55930   {
55931     try {
55932       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);
55933     } catch (std::out_of_range& e) {
55934       {
55935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55936       };
55937     } catch (std::exception& e) {
55938       {
55939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55940       };
55941     } catch (Dali::DaliException e) {
55942       {
55943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55944       };
55945     } catch (...) {
55946       {
55947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55948       };
55949     }
55950   }
55951
55952   jresult = (unsigned long)result;
55953   return jresult;
55954 }
55955
55956
55957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
55958   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55959   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55960
55961   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55962   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55963   {
55964     try {
55965       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55966     } catch (std::out_of_range& e) {
55967       {
55968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55969       };
55970     } catch (std::exception& e) {
55971       {
55972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55973       };
55974     } catch (Dali::DaliException e) {
55975       {
55976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55977       };
55978     } catch (...) {
55979       {
55980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55981       };
55982     }
55983   }
55984
55985 }
55986
55987
55988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
55989   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55990   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55991
55992   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55993   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55994   {
55995     try {
55996       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55997     } catch (std::out_of_range& e) {
55998       {
55999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56000       };
56001     } catch (std::exception& e) {
56002       {
56003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56004       };
56005     } catch (Dali::DaliException e) {
56006       {
56007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56008       };
56009     } catch (...) {
56010       {
56011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56012       };
56013     }
56014   }
56015
56016 }
56017
56018
56019 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
56020   unsigned int jresult ;
56021   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
56022   Dali::Actor arg2 ;
56023   Dali::WheelEvent *arg3 = 0 ;
56024   Dali::Actor *argp2 ;
56025   bool result;
56026
56027   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
56028   argp2 = (Dali::Actor *)jarg2;
56029   if (!argp2) {
56030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56031     return 0;
56032   }
56033   arg2 = *argp2;
56034   arg3 = (Dali::WheelEvent *)jarg3;
56035   if (!arg3) {
56036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56037     return 0;
56038   }
56039   {
56040     try {
56041       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
56042     } catch (std::out_of_range& e) {
56043       {
56044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56045       };
56046     } catch (std::exception& e) {
56047       {
56048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56049       };
56050     } catch (Dali::DaliException e) {
56051       {
56052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56053       };
56054     } catch (...) {
56055       {
56056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56057       };
56058     }
56059   }
56060
56061   jresult = result;
56062   return jresult;
56063 }
56064
56065
56066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
56067   void * jresult ;
56068   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
56069
56070   {
56071     try {
56072       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
56073     } catch (std::out_of_range& e) {
56074       {
56075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56076       };
56077     } catch (std::exception& e) {
56078       {
56079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56080       };
56081     } catch (Dali::DaliException e) {
56082       {
56083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56084       };
56085     } catch (...) {
56086       {
56087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56088       };
56089     }
56090   }
56091
56092   jresult = (void *)result;
56093   return jresult;
56094 }
56095
56096
56097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
56098   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
56099
56100   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
56101   {
56102     try {
56103       delete arg1;
56104     } catch (std::out_of_range& e) {
56105       {
56106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56107       };
56108     } catch (std::exception& e) {
56109       {
56110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56111       };
56112     } catch (Dali::DaliException e) {
56113       {
56114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56115       };
56116     } catch (...) {
56117       {
56118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56119       };
56120     }
56121   }
56122
56123 }
56124
56125
56126 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
56127   unsigned int jresult ;
56128   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56129   bool result;
56130
56131   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56132   {
56133     try {
56134       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
56135     } catch (std::out_of_range& e) {
56136       {
56137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56138       };
56139     } catch (std::exception& e) {
56140       {
56141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56142       };
56143     } catch (Dali::DaliException e) {
56144       {
56145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56146       };
56147     } catch (...) {
56148       {
56149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56150       };
56151     }
56152   }
56153
56154   jresult = result;
56155   return jresult;
56156 }
56157
56158
56159 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
56160   unsigned long jresult ;
56161   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56162   std::size_t result;
56163
56164   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56165   {
56166     try {
56167       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
56168     } catch (std::out_of_range& e) {
56169       {
56170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56171       };
56172     } catch (std::exception& e) {
56173       {
56174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56175       };
56176     } catch (Dali::DaliException e) {
56177       {
56178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56179       };
56180     } catch (...) {
56181       {
56182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56183       };
56184     }
56185   }
56186
56187   jresult = (unsigned long)result;
56188   return jresult;
56189 }
56190
56191
56192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
56193   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56194   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56195
56196   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56197   arg2 = (void (*)(Dali::Actor))jarg2;
56198   {
56199     try {
56200       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
56201     } catch (std::out_of_range& e) {
56202       {
56203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56204       };
56205     } catch (std::exception& e) {
56206       {
56207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56208       };
56209     } catch (Dali::DaliException e) {
56210       {
56211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56212       };
56213     } catch (...) {
56214       {
56215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56216       };
56217     }
56218   }
56219
56220 }
56221
56222
56223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
56224   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56225   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56226
56227   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56228   arg2 = (void (*)(Dali::Actor))jarg2;
56229   {
56230     try {
56231       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
56232     } catch (std::out_of_range& e) {
56233       {
56234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56235       };
56236     } catch (std::exception& e) {
56237       {
56238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56239       };
56240     } catch (Dali::DaliException e) {
56241       {
56242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56243       };
56244     } catch (...) {
56245       {
56246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56247       };
56248     }
56249   }
56250
56251 }
56252
56253
56254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
56255   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56256   Dali::Actor arg2 ;
56257   Dali::Actor *argp2 ;
56258
56259   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56260   argp2 = (Dali::Actor *)jarg2;
56261   if (!argp2) {
56262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56263     return ;
56264   }
56265   arg2 = *argp2;
56266   {
56267     try {
56268       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
56269     } catch (std::out_of_range& e) {
56270       {
56271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56272       };
56273     } catch (std::exception& e) {
56274       {
56275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56276       };
56277     } catch (Dali::DaliException e) {
56278       {
56279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56280       };
56281     } catch (...) {
56282       {
56283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56284       };
56285     }
56286   }
56287
56288 }
56289
56290
56291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
56292   void * jresult ;
56293   Dali::Signal< void (Dali::Actor) > *result = 0 ;
56294
56295   {
56296     try {
56297       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
56298     } catch (std::out_of_range& e) {
56299       {
56300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56301       };
56302     } catch (std::exception& e) {
56303       {
56304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56305       };
56306     } catch (Dali::DaliException e) {
56307       {
56308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56309       };
56310     } catch (...) {
56311       {
56312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56313       };
56314     }
56315   }
56316
56317   jresult = (void *)result;
56318   return jresult;
56319 }
56320
56321
56322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
56323   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56324
56325   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56326   {
56327     try {
56328       delete arg1;
56329     } catch (std::out_of_range& e) {
56330       {
56331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56332       };
56333     } catch (std::exception& e) {
56334       {
56335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56336       };
56337     } catch (Dali::DaliException e) {
56338       {
56339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56340       };
56341     } catch (...) {
56342       {
56343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56344       };
56345     }
56346   }
56347
56348 }
56349
56350
56351 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
56352   unsigned int jresult ;
56353   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56354   bool result;
56355
56356   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56357   {
56358     try {
56359       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56360     } catch (std::out_of_range& e) {
56361       {
56362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56363       };
56364     } catch (std::exception& e) {
56365       {
56366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56367       };
56368     } catch (Dali::DaliException e) {
56369       {
56370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56371       };
56372     } catch (...) {
56373       {
56374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56375       };
56376     }
56377   }
56378
56379   jresult = result;
56380   return jresult;
56381 }
56382
56383
56384 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
56385   unsigned long jresult ;
56386   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56387   std::size_t result;
56388
56389   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56390   {
56391     try {
56392       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56393     } catch (std::out_of_range& e) {
56394       {
56395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56396       };
56397     } catch (std::exception& e) {
56398       {
56399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56400       };
56401     } catch (Dali::DaliException e) {
56402       {
56403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56404       };
56405     } catch (...) {
56406       {
56407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56408       };
56409     }
56410   }
56411
56412   jresult = (unsigned long)result;
56413   return jresult;
56414 }
56415
56416
56417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
56418   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56419   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56420
56421   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56422   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56423   {
56424     try {
56425       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56426     } catch (std::out_of_range& e) {
56427       {
56428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56429       };
56430     } catch (std::exception& e) {
56431       {
56432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56433       };
56434     } catch (Dali::DaliException e) {
56435       {
56436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56437       };
56438     } catch (...) {
56439       {
56440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56441       };
56442     }
56443   }
56444
56445 }
56446
56447
56448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
56449   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56450   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56451
56452   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56453   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56454   {
56455     try {
56456       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56457     } catch (std::out_of_range& e) {
56458       {
56459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56460       };
56461     } catch (std::exception& e) {
56462       {
56463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56464       };
56465     } catch (Dali::DaliException e) {
56466       {
56467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56468       };
56469     } catch (...) {
56470       {
56471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56472       };
56473     }
56474   }
56475
56476 }
56477
56478
56479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
56480   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56481   Dali::KeyEvent *arg2 = 0 ;
56482
56483   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56484   arg2 = (Dali::KeyEvent *)jarg2;
56485   if (!arg2) {
56486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56487     return ;
56488   }
56489   {
56490     try {
56491       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
56492     } catch (std::out_of_range& e) {
56493       {
56494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56495       };
56496     } catch (std::exception& e) {
56497       {
56498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56499       };
56500     } catch (Dali::DaliException e) {
56501       {
56502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56503       };
56504     } catch (...) {
56505       {
56506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56507       };
56508     }
56509   }
56510
56511 }
56512
56513
56514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
56515   void * jresult ;
56516   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
56517
56518   {
56519     try {
56520       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
56521     } catch (std::out_of_range& e) {
56522       {
56523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56524       };
56525     } catch (std::exception& e) {
56526       {
56527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56528       };
56529     } catch (Dali::DaliException e) {
56530       {
56531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56532       };
56533     } catch (...) {
56534       {
56535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56536       };
56537     }
56538   }
56539
56540   jresult = (void *)result;
56541   return jresult;
56542 }
56543
56544
56545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
56546   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56547
56548   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56549   {
56550     try {
56551       delete arg1;
56552     } catch (std::out_of_range& e) {
56553       {
56554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56555       };
56556     } catch (std::exception& e) {
56557       {
56558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56559       };
56560     } catch (Dali::DaliException e) {
56561       {
56562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56563       };
56564     } catch (...) {
56565       {
56566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56567       };
56568     }
56569   }
56570
56571 }
56572
56573
56574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
56575   unsigned int jresult ;
56576   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56577   bool result;
56578
56579   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56580   {
56581     try {
56582       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56583     } catch (std::out_of_range& e) {
56584       {
56585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56586       };
56587     } catch (std::exception& e) {
56588       {
56589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56590       };
56591     } catch (Dali::DaliException e) {
56592       {
56593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56594       };
56595     } catch (...) {
56596       {
56597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56598       };
56599     }
56600   }
56601
56602   jresult = result;
56603   return jresult;
56604 }
56605
56606
56607 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
56608   unsigned long jresult ;
56609   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56610   std::size_t result;
56611
56612   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56613   {
56614     try {
56615       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
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 = (unsigned long)result;
56636   return jresult;
56637 }
56638
56639
56640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
56641   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56642   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56643
56644   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56645   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56646   {
56647     try {
56648       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56649     } catch (std::out_of_range& e) {
56650       {
56651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56652       };
56653     } catch (std::exception& e) {
56654       {
56655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56656       };
56657     } catch (Dali::DaliException e) {
56658       {
56659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56660       };
56661     } catch (...) {
56662       {
56663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56664       };
56665     }
56666   }
56667
56668 }
56669
56670
56671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
56672   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56673   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56674
56675   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56676   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56677   {
56678     try {
56679       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56680     } catch (std::out_of_range& e) {
56681       {
56682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56683       };
56684     } catch (std::exception& e) {
56685       {
56686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56687       };
56688     } catch (Dali::DaliException e) {
56689       {
56690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56691       };
56692     } catch (...) {
56693       {
56694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56695       };
56696     }
56697   }
56698
56699 }
56700
56701
56702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
56703   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56704   Dali::TouchData *arg2 = 0 ;
56705
56706   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56707   arg2 = (Dali::TouchData *)jarg2;
56708   if (!arg2) {
56709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
56710     return ;
56711   }
56712   {
56713     try {
56714       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
56715     } catch (std::out_of_range& e) {
56716       {
56717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56718       };
56719     } catch (std::exception& e) {
56720       {
56721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56722       };
56723     } catch (Dali::DaliException e) {
56724       {
56725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56726       };
56727     } catch (...) {
56728       {
56729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56730       };
56731     }
56732   }
56733
56734 }
56735
56736
56737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
56738   void * jresult ;
56739   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
56740
56741   {
56742     try {
56743       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
56744     } catch (std::out_of_range& e) {
56745       {
56746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56747       };
56748     } catch (std::exception& e) {
56749       {
56750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56751       };
56752     } catch (Dali::DaliException e) {
56753       {
56754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56755       };
56756     } catch (...) {
56757       {
56758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56759       };
56760     }
56761   }
56762
56763   jresult = (void *)result;
56764   return jresult;
56765 }
56766
56767
56768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
56769   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56770
56771   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56772   {
56773     try {
56774       delete arg1;
56775     } catch (std::out_of_range& e) {
56776       {
56777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56778       };
56779     } catch (std::exception& e) {
56780       {
56781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56782       };
56783     } catch (Dali::DaliException e) {
56784       {
56785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56786       };
56787     } catch (...) {
56788       {
56789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56790       };
56791     }
56792   }
56793
56794 }
56795
56796
56797 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
56798   unsigned int jresult ;
56799   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56800   bool result;
56801
56802   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56803   {
56804     try {
56805       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56806     } catch (std::out_of_range& e) {
56807       {
56808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56809       };
56810     } catch (std::exception& e) {
56811       {
56812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56813       };
56814     } catch (Dali::DaliException e) {
56815       {
56816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56817       };
56818     } catch (...) {
56819       {
56820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56821       };
56822     }
56823   }
56824
56825   jresult = result;
56826   return jresult;
56827 }
56828
56829
56830 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
56831   unsigned long jresult ;
56832   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56833   std::size_t result;
56834
56835   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56836   {
56837     try {
56838       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56839     } catch (std::out_of_range& e) {
56840       {
56841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56842       };
56843     } catch (std::exception& e) {
56844       {
56845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56846       };
56847     } catch (Dali::DaliException e) {
56848       {
56849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56850       };
56851     } catch (...) {
56852       {
56853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56854       };
56855     }
56856   }
56857
56858   jresult = (unsigned long)result;
56859   return jresult;
56860 }
56861
56862
56863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
56864   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56865   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56866
56867   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56868   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56869   {
56870     try {
56871       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56872     } catch (std::out_of_range& e) {
56873       {
56874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56875       };
56876     } catch (std::exception& e) {
56877       {
56878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56879       };
56880     } catch (Dali::DaliException e) {
56881       {
56882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56883       };
56884     } catch (...) {
56885       {
56886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56887       };
56888     }
56889   }
56890
56891 }
56892
56893
56894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
56895   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56896   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56897
56898   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56899   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56900   {
56901     try {
56902       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56903     } catch (std::out_of_range& e) {
56904       {
56905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56906       };
56907     } catch (std::exception& e) {
56908       {
56909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56910       };
56911     } catch (Dali::DaliException e) {
56912       {
56913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56914       };
56915     } catch (...) {
56916       {
56917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56918       };
56919     }
56920   }
56921
56922 }
56923
56924
56925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
56926   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56927   Dali::WheelEvent *arg2 = 0 ;
56928
56929   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56930   arg2 = (Dali::WheelEvent *)jarg2;
56931   if (!arg2) {
56932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56933     return ;
56934   }
56935   {
56936     try {
56937       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
56938     } catch (std::out_of_range& e) {
56939       {
56940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56941       };
56942     } catch (std::exception& e) {
56943       {
56944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56945       };
56946     } catch (Dali::DaliException e) {
56947       {
56948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56949       };
56950     } catch (...) {
56951       {
56952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56953       };
56954     }
56955   }
56956
56957 }
56958
56959
56960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
56961   void * jresult ;
56962   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
56963
56964   {
56965     try {
56966       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
56967     } catch (std::out_of_range& e) {
56968       {
56969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56970       };
56971     } catch (std::exception& e) {
56972       {
56973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56974       };
56975     } catch (Dali::DaliException e) {
56976       {
56977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56978       };
56979     } catch (...) {
56980       {
56981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56982       };
56983     }
56984   }
56985
56986   jresult = (void *)result;
56987   return jresult;
56988 }
56989
56990
56991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
56992   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56993
56994   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56995   {
56996     try {
56997       delete arg1;
56998     } catch (std::out_of_range& e) {
56999       {
57000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57001       };
57002     } catch (std::exception& e) {
57003       {
57004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57005       };
57006     } catch (Dali::DaliException e) {
57007       {
57008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57009       };
57010     } catch (...) {
57011       {
57012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57013       };
57014     }
57015   }
57016
57017 }
57018
57019
57020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
57021   void * jresult ;
57022   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
57023
57024   {
57025     try {
57026       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
57027     } catch (std::out_of_range& e) {
57028       {
57029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57030       };
57031     } catch (std::exception& e) {
57032       {
57033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57034       };
57035     } catch (Dali::DaliException e) {
57036       {
57037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57038       };
57039     } catch (...) {
57040       {
57041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57042       };
57043     }
57044   }
57045
57046   jresult = (void *)result;
57047   return jresult;
57048 }
57049
57050
57051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
57052   void * jresult ;
57053   Dali::Radian arg1 ;
57054   Dali::Radian arg2 ;
57055   Dali::Radian *argp1 ;
57056   Dali::Radian *argp2 ;
57057   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
57058
57059   argp1 = (Dali::Radian *)jarg1;
57060   if (!argp1) {
57061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
57062     return 0;
57063   }
57064   arg1 = *argp1;
57065   argp2 = (Dali::Radian *)jarg2;
57066   if (!argp2) {
57067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
57068     return 0;
57069   }
57070   arg2 = *argp2;
57071   {
57072     try {
57073       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
57074     } catch (std::out_of_range& e) {
57075       {
57076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57077       };
57078     } catch (std::exception& e) {
57079       {
57080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57081       };
57082     } catch (Dali::DaliException e) {
57083       {
57084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57085       };
57086     } catch (...) {
57087       {
57088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57089       };
57090     }
57091   }
57092
57093   jresult = (void *)result;
57094   return jresult;
57095 }
57096
57097
57098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
57099   void * jresult ;
57100   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
57101   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
57102
57103   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57104   if (!arg1) {
57105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
57106     return 0;
57107   }
57108   {
57109     try {
57110       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
57111     } catch (std::out_of_range& e) {
57112       {
57113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57114       };
57115     } catch (std::exception& e) {
57116       {
57117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57118       };
57119     } catch (Dali::DaliException e) {
57120       {
57121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57122       };
57123     } catch (...) {
57124       {
57125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57126       };
57127     }
57128   }
57129
57130   jresult = (void *)result;
57131   return jresult;
57132 }
57133
57134
57135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
57136   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57137   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57138
57139   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57140   arg2 = (Dali::Radian *)jarg2;
57141   if (arg1) (arg1)->first = *arg2;
57142 }
57143
57144
57145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
57146   void * jresult ;
57147   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57148   Dali::Radian *result = 0 ;
57149
57150   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57151   result = (Dali::Radian *)& ((arg1)->first);
57152   jresult = (void *)result;
57153   return jresult;
57154 }
57155
57156
57157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
57158   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57159   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57160
57161   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57162   arg2 = (Dali::Radian *)jarg2;
57163   if (arg1) (arg1)->second = *arg2;
57164 }
57165
57166
57167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
57168   void * jresult ;
57169   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57170   Dali::Radian *result = 0 ;
57171
57172   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57173   result = (Dali::Radian *)& ((arg1)->second);
57174   jresult = (void *)result;
57175   return jresult;
57176 }
57177
57178
57179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
57180   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57181
57182   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57183   {
57184     try {
57185       delete arg1;
57186     } catch (std::out_of_range& e) {
57187       {
57188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57189       };
57190     } catch (std::exception& e) {
57191       {
57192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57193       };
57194     } catch (Dali::DaliException e) {
57195       {
57196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57197       };
57198     } catch (...) {
57199       {
57200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57201       };
57202     }
57203   }
57204
57205 }
57206
57207
57208 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
57209   unsigned int jresult ;
57210   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57211   bool result;
57212
57213   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57214   {
57215     try {
57216       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);
57217     } catch (std::out_of_range& e) {
57218       {
57219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57220       };
57221     } catch (std::exception& e) {
57222       {
57223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57224       };
57225     } catch (Dali::DaliException e) {
57226       {
57227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57228       };
57229     } catch (...) {
57230       {
57231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57232       };
57233     }
57234   }
57235
57236   jresult = result;
57237   return jresult;
57238 }
57239
57240
57241 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57242   unsigned long jresult ;
57243   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57244   std::size_t result;
57245
57246   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57247   {
57248     try {
57249       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);
57250     } catch (std::out_of_range& e) {
57251       {
57252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57253       };
57254     } catch (std::exception& e) {
57255       {
57256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57257       };
57258     } catch (Dali::DaliException e) {
57259       {
57260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57261       };
57262     } catch (...) {
57263       {
57264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57265       };
57266     }
57267   }
57268
57269   jresult = (unsigned long)result;
57270   return jresult;
57271 }
57272
57273
57274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57275   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57276   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57277
57278   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57279   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57280   {
57281     try {
57282       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57283     } catch (std::out_of_range& e) {
57284       {
57285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57286       };
57287     } catch (std::exception& e) {
57288       {
57289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57290       };
57291     } catch (Dali::DaliException e) {
57292       {
57293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57294       };
57295     } catch (...) {
57296       {
57297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57298       };
57299     }
57300   }
57301
57302 }
57303
57304
57305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57306   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57307   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57308
57309   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57310   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57311   {
57312     try {
57313       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57314     } catch (std::out_of_range& e) {
57315       {
57316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57317       };
57318     } catch (std::exception& e) {
57319       {
57320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57321       };
57322     } catch (Dali::DaliException e) {
57323       {
57324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57325       };
57326     } catch (...) {
57327       {
57328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57329       };
57330     }
57331   }
57332
57333 }
57334
57335
57336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57337   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57338   Dali::Actor arg2 ;
57339   Dali::PanGesture *arg3 = 0 ;
57340   Dali::Actor *argp2 ;
57341
57342   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57343   argp2 = (Dali::Actor *)jarg2;
57344   if (!argp2) {
57345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57346     return ;
57347   }
57348   arg2 = *argp2;
57349   arg3 = (Dali::PanGesture *)jarg3;
57350   if (!arg3) {
57351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57352     return ;
57353   }
57354   {
57355     try {
57356       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
57357     } catch (std::out_of_range& e) {
57358       {
57359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57360       };
57361     } catch (std::exception& e) {
57362       {
57363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57364       };
57365     } catch (Dali::DaliException e) {
57366       {
57367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57368       };
57369     } catch (...) {
57370       {
57371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57372       };
57373     }
57374   }
57375
57376 }
57377
57378
57379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
57380   void * jresult ;
57381   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
57382
57383   {
57384     try {
57385       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
57386     } catch (std::out_of_range& e) {
57387       {
57388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57389       };
57390     } catch (std::exception& e) {
57391       {
57392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57393       };
57394     } catch (Dali::DaliException e) {
57395       {
57396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57397       };
57398     } catch (...) {
57399       {
57400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57401       };
57402     }
57403   }
57404
57405   jresult = (void *)result;
57406   return jresult;
57407 }
57408
57409
57410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
57411   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57412
57413   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57414   {
57415     try {
57416       delete arg1;
57417     } catch (std::out_of_range& e) {
57418       {
57419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57420       };
57421     } catch (std::exception& e) {
57422       {
57423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57424       };
57425     } catch (Dali::DaliException e) {
57426       {
57427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57428       };
57429     } catch (...) {
57430       {
57431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57432       };
57433     }
57434   }
57435
57436 }
57437
57438
57439 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
57440   unsigned int jresult ;
57441   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57442   bool result;
57443
57444   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57445   {
57446     try {
57447       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);
57448     } catch (std::out_of_range& e) {
57449       {
57450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57451       };
57452     } catch (std::exception& e) {
57453       {
57454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57455       };
57456     } catch (Dali::DaliException e) {
57457       {
57458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57459       };
57460     } catch (...) {
57461       {
57462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57463       };
57464     }
57465   }
57466
57467   jresult = result;
57468   return jresult;
57469 }
57470
57471
57472 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57473   unsigned long jresult ;
57474   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57475   std::size_t result;
57476
57477   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57478   {
57479     try {
57480       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);
57481     } catch (std::out_of_range& e) {
57482       {
57483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57484       };
57485     } catch (std::exception& e) {
57486       {
57487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57488       };
57489     } catch (Dali::DaliException e) {
57490       {
57491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57492       };
57493     } catch (...) {
57494       {
57495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57496       };
57497     }
57498   }
57499
57500   jresult = (unsigned long)result;
57501   return jresult;
57502 }
57503
57504
57505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57506   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57507   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57508
57509   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57510   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57511   {
57512     try {
57513       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57514     } catch (std::out_of_range& e) {
57515       {
57516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57517       };
57518     } catch (std::exception& e) {
57519       {
57520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57521       };
57522     } catch (Dali::DaliException e) {
57523       {
57524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57525       };
57526     } catch (...) {
57527       {
57528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57529       };
57530     }
57531   }
57532
57533 }
57534
57535
57536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57537   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57538   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57539
57540   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57541   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57542   {
57543     try {
57544       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57545     } catch (std::out_of_range& e) {
57546       {
57547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57548       };
57549     } catch (std::exception& e) {
57550       {
57551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57552       };
57553     } catch (Dali::DaliException e) {
57554       {
57555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57556       };
57557     } catch (...) {
57558       {
57559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57560       };
57561     }
57562   }
57563
57564 }
57565
57566
57567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57568   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57569   Dali::Actor arg2 ;
57570   Dali::PinchGesture *arg3 = 0 ;
57571   Dali::Actor *argp2 ;
57572
57573   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57574   argp2 = (Dali::Actor *)jarg2;
57575   if (!argp2) {
57576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57577     return ;
57578   }
57579   arg2 = *argp2;
57580   arg3 = (Dali::PinchGesture *)jarg3;
57581   if (!arg3) {
57582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57583     return ;
57584   }
57585   {
57586     try {
57587       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
57588     } catch (std::out_of_range& e) {
57589       {
57590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57591       };
57592     } catch (std::exception& e) {
57593       {
57594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57595       };
57596     } catch (Dali::DaliException e) {
57597       {
57598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57599       };
57600     } catch (...) {
57601       {
57602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57603       };
57604     }
57605   }
57606
57607 }
57608
57609
57610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
57611   void * jresult ;
57612   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
57613
57614   {
57615     try {
57616       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
57617     } catch (std::out_of_range& e) {
57618       {
57619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57620       };
57621     } catch (std::exception& e) {
57622       {
57623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57624       };
57625     } catch (Dali::DaliException e) {
57626       {
57627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57628       };
57629     } catch (...) {
57630       {
57631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57632       };
57633     }
57634   }
57635
57636   jresult = (void *)result;
57637   return jresult;
57638 }
57639
57640
57641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
57642   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57643
57644   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57645   {
57646     try {
57647       delete arg1;
57648     } catch (std::out_of_range& e) {
57649       {
57650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57651       };
57652     } catch (std::exception& e) {
57653       {
57654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57655       };
57656     } catch (Dali::DaliException e) {
57657       {
57658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57659       };
57660     } catch (...) {
57661       {
57662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57663       };
57664     }
57665   }
57666
57667 }
57668
57669
57670 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
57671   unsigned int jresult ;
57672   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57673   bool result;
57674
57675   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57676   {
57677     try {
57678       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);
57679     } catch (std::out_of_range& e) {
57680       {
57681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57682       };
57683     } catch (std::exception& e) {
57684       {
57685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57686       };
57687     } catch (Dali::DaliException e) {
57688       {
57689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57690       };
57691     } catch (...) {
57692       {
57693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57694       };
57695     }
57696   }
57697
57698   jresult = result;
57699   return jresult;
57700 }
57701
57702
57703 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57704   unsigned long jresult ;
57705   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57706   std::size_t result;
57707
57708   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57709   {
57710     try {
57711       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);
57712     } catch (std::out_of_range& e) {
57713       {
57714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57715       };
57716     } catch (std::exception& e) {
57717       {
57718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57719       };
57720     } catch (Dali::DaliException e) {
57721       {
57722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57723       };
57724     } catch (...) {
57725       {
57726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57727       };
57728     }
57729   }
57730
57731   jresult = (unsigned long)result;
57732   return jresult;
57733 }
57734
57735
57736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57737   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57738   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57739
57740   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57741   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57742   {
57743     try {
57744       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57745     } catch (std::out_of_range& e) {
57746       {
57747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57748       };
57749     } catch (std::exception& e) {
57750       {
57751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57752       };
57753     } catch (Dali::DaliException e) {
57754       {
57755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57756       };
57757     } catch (...) {
57758       {
57759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57760       };
57761     }
57762   }
57763
57764 }
57765
57766
57767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57768   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57769   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57770
57771   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57772   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57773   {
57774     try {
57775       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57776     } catch (std::out_of_range& e) {
57777       {
57778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57779       };
57780     } catch (std::exception& e) {
57781       {
57782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57783       };
57784     } catch (Dali::DaliException e) {
57785       {
57786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57787       };
57788     } catch (...) {
57789       {
57790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57791       };
57792     }
57793   }
57794
57795 }
57796
57797
57798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57799   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57800   Dali::Actor arg2 ;
57801   Dali::TapGesture *arg3 = 0 ;
57802   Dali::Actor *argp2 ;
57803
57804   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57805   argp2 = (Dali::Actor *)jarg2;
57806   if (!argp2) {
57807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57808     return ;
57809   }
57810   arg2 = *argp2;
57811   arg3 = (Dali::TapGesture *)jarg3;
57812   if (!arg3) {
57813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57814     return ;
57815   }
57816   {
57817     try {
57818       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
57819     } catch (std::out_of_range& e) {
57820       {
57821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57822       };
57823     } catch (std::exception& e) {
57824       {
57825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57826       };
57827     } catch (Dali::DaliException e) {
57828       {
57829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57830       };
57831     } catch (...) {
57832       {
57833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57834       };
57835     }
57836   }
57837
57838 }
57839
57840
57841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
57842   void * jresult ;
57843   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
57844
57845   {
57846     try {
57847       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
57848     } catch (std::out_of_range& e) {
57849       {
57850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57851       };
57852     } catch (std::exception& e) {
57853       {
57854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57855       };
57856     } catch (Dali::DaliException e) {
57857       {
57858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57859       };
57860     } catch (...) {
57861       {
57862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57863       };
57864     }
57865   }
57866
57867   jresult = (void *)result;
57868   return jresult;
57869 }
57870
57871
57872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
57873   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57874
57875   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57876   {
57877     try {
57878       delete arg1;
57879     } catch (std::out_of_range& e) {
57880       {
57881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57882       };
57883     } catch (std::exception& e) {
57884       {
57885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57886       };
57887     } catch (Dali::DaliException e) {
57888       {
57889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57890       };
57891     } catch (...) {
57892       {
57893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57894       };
57895     }
57896   }
57897
57898 }
57899
57900 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
57901   unsigned int jresult ;
57902   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57903   bool result;
57904
57905   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57906   {
57907     try {
57908       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57909     } catch (std::out_of_range& e) {
57910       {
57911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57912       };
57913     } catch (std::exception& e) {
57914       {
57915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57916       };
57917     } catch (Dali::DaliException e) {
57918       {
57919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57920       };
57921     } catch (...) {
57922       {
57923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57924       };
57925     }
57926   }
57927
57928   jresult = result;
57929   return jresult;
57930 }
57931
57932
57933 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
57934   unsigned long jresult ;
57935   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57936   std::size_t result;
57937
57938   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57939   {
57940     try {
57941       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57942     } catch (std::out_of_range& e) {
57943       {
57944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57945       };
57946     } catch (std::exception& e) {
57947       {
57948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57949       };
57950     } catch (Dali::DaliException e) {
57951       {
57952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57953       };
57954     } catch (...) {
57955       {
57956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57957       };
57958     }
57959   }
57960
57961   jresult = (unsigned long)result;
57962   return jresult;
57963 }
57964
57965
57966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
57967   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57968   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57969
57970   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57971   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57972   {
57973     try {
57974       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
57975     } catch (std::out_of_range& e) {
57976       {
57977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57978       };
57979     } catch (std::exception& e) {
57980       {
57981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57982       };
57983     } catch (Dali::DaliException e) {
57984       {
57985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57986       };
57987     } catch (...) {
57988       {
57989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57990       };
57991     }
57992   }
57993
57994 }
57995
57996
57997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
57998   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57999   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
58000
58001   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
58002   arg2 = (void (*)(Dali::ResourceImage))jarg2;
58003   {
58004     try {
58005       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
58006     } catch (std::out_of_range& e) {
58007       {
58008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58009       };
58010     } catch (std::exception& e) {
58011       {
58012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58013       };
58014     } catch (Dali::DaliException e) {
58015       {
58016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58017       };
58018     } catch (...) {
58019       {
58020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58021       };
58022     }
58023   }
58024
58025 }
58026
58027
58028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
58029   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
58030   Dali::ResourceImage arg2 ;
58031   Dali::ResourceImage *argp2 ;
58032
58033   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
58034   argp2 = (Dali::ResourceImage *)jarg2;
58035   if (!argp2) {
58036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
58037     return ;
58038   }
58039   arg2 = *argp2;
58040   {
58041     try {
58042       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
58043     } catch (std::out_of_range& e) {
58044       {
58045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58046       };
58047     } catch (std::exception& e) {
58048       {
58049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58050       };
58051     } catch (Dali::DaliException e) {
58052       {
58053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58054       };
58055     } catch (...) {
58056       {
58057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58058       };
58059     }
58060   }
58061
58062 }
58063
58064
58065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
58066   void * jresult ;
58067   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
58068
58069   {
58070     try {
58071       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
58072     } catch (std::out_of_range& e) {
58073       {
58074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58075       };
58076     } catch (std::exception& e) {
58077       {
58078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58079       };
58080     } catch (Dali::DaliException e) {
58081       {
58082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58083       };
58084     } catch (...) {
58085       {
58086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58087       };
58088     }
58089   }
58090
58091   jresult = (void *)result;
58092   return jresult;
58093 }
58094
58095
58096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
58097   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
58098
58099   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
58100   {
58101     try {
58102       delete arg1;
58103     } catch (std::out_of_range& e) {
58104       {
58105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58106       };
58107     } catch (std::exception& e) {
58108       {
58109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58110       };
58111     } catch (Dali::DaliException e) {
58112       {
58113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58114       };
58115     } catch (...) {
58116       {
58117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58118       };
58119     }
58120   }
58121
58122 }
58123
58124 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
58125   unsigned int jresult ;
58126   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58127   bool result = false;
58128
58129   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58130   {
58131     try {
58132       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);
58133     } catch (std::out_of_range& e) {
58134       {
58135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58136       };
58137     } catch (std::exception& e) {
58138       {
58139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58140       };
58141     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58142   }
58143   jresult = result;
58144   return jresult;
58145 }
58146
58147 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
58148   unsigned long jresult ;
58149   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58150   std::size_t result = 0;
58151
58152   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58153   {
58154     try {
58155       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);
58156     } catch (std::out_of_range& e) {
58157       {
58158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58159       };
58160     } catch (std::exception& e) {
58161       {
58162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58163       };
58164     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58165   }
58166   jresult = (unsigned long)result;
58167   return jresult;
58168 }
58169
58170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
58171   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58172   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58173
58174   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58175   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58176   {
58177     try {
58178       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
58179     } catch (std::out_of_range& e) {
58180       {
58181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58182       };
58183     } catch (std::exception& e) {
58184       {
58185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58186       };
58187     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58188   }
58189 }
58190
58191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
58192   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58193   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58194
58195   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58196   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58197   {
58198     try {
58199       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
58200     } catch (std::out_of_range& e) {
58201       {
58202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58203       };
58204     } catch (std::exception& e) {
58205       {
58206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58207       };
58208     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58209   }
58210 }
58211
58212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
58213   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58214   Dali::Actor arg2 ;
58215   //bool arg3 ;
58216   Dali::LayoutDirection::Type arg4 ;
58217   Dali::Actor *argp2 ;
58218
58219   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58220   argp2 = (Dali::Actor *)jarg2;
58221   if (!argp2) {
58222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58223     return ;
58224   }
58225   arg2 = *argp2;
58226   //arg3 = jarg3 ? true : false;
58227   arg4 = (Dali::LayoutDirection::Type)jarg4;
58228   {
58229     try {
58230       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
58231     } catch (std::out_of_range& e) {
58232       {
58233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58234       };
58235     } catch (std::exception& e) {
58236       {
58237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58238       };
58239     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58240   }
58241 }
58242
58243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
58244   void * jresult ;
58245   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
58246
58247   {
58248     try {
58249       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
58250     } catch (std::out_of_range& e) {
58251       {
58252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58253       };
58254     } catch (std::exception& e) {
58255       {
58256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58257       };
58258     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58259   }
58260   jresult = (void *)result;
58261   return jresult;
58262 }
58263
58264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
58265   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58266
58267   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58268   {
58269     try {
58270       delete arg1;
58271     } catch (std::out_of_range& e) {
58272       {
58273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58274       };
58275     } catch (std::exception& e) {
58276       {
58277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58278       };
58279     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58280   }
58281 }
58282
58283 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
58284   unsigned int jresult ;
58285   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58286   bool result;
58287
58288   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58289   {
58290     try {
58291       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);
58292     } catch (std::out_of_range& e) {
58293       {
58294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58295       };
58296     } catch (std::exception& e) {
58297       {
58298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58299       };
58300     } catch (Dali::DaliException e) {
58301       {
58302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58303       };
58304     } catch (...) {
58305       {
58306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58307       };
58308     }
58309   }
58310
58311   jresult = result;
58312   return jresult;
58313 }
58314
58315
58316 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
58317   unsigned long jresult ;
58318   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58319   std::size_t result;
58320
58321   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58322   {
58323     try {
58324       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);
58325     } catch (std::out_of_range& e) {
58326       {
58327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58328       };
58329     } catch (std::exception& e) {
58330       {
58331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58332       };
58333     } catch (Dali::DaliException e) {
58334       {
58335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58336       };
58337     } catch (...) {
58338       {
58339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58340       };
58341     }
58342   }
58343
58344   jresult = (unsigned long)result;
58345   return jresult;
58346 }
58347
58348
58349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
58350   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58351   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58352
58353   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58354   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58355   {
58356     try {
58357       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
58358     } catch (std::out_of_range& e) {
58359       {
58360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58361       };
58362     } catch (std::exception& e) {
58363       {
58364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58365       };
58366     } catch (Dali::DaliException e) {
58367       {
58368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58369       };
58370     } catch (...) {
58371       {
58372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58373       };
58374     }
58375   }
58376
58377 }
58378
58379
58380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
58381   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58382   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58383
58384   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58385   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58386   {
58387     try {
58388       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
58389     } catch (std::out_of_range& e) {
58390       {
58391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58392       };
58393     } catch (std::exception& e) {
58394       {
58395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58396       };
58397     } catch (Dali::DaliException e) {
58398       {
58399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58400       };
58401     } catch (...) {
58402       {
58403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58404       };
58405     }
58406   }
58407
58408 }
58409
58410
58411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
58412   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58413   Dali::Actor arg2 ;
58414   bool arg3 ;
58415   Dali::DevelActor::VisibilityChange::Type arg4 ;
58416   Dali::Actor *argp2 ;
58417
58418   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58419   argp2 = (Dali::Actor *)jarg2;
58420   if (!argp2) {
58421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58422     return ;
58423   }
58424   arg2 = *argp2;
58425   arg3 = jarg3 ? true : false;
58426   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
58427   {
58428     try {
58429       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
58430     } catch (std::out_of_range& e) {
58431       {
58432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58433       };
58434     } catch (std::exception& e) {
58435       {
58436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58437       };
58438     } catch (Dali::DaliException e) {
58439       {
58440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58441       };
58442     } catch (...) {
58443       {
58444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58445       };
58446     }
58447   }
58448
58449 }
58450
58451
58452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
58453   void * jresult ;
58454   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
58455
58456   {
58457     try {
58458       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
58459     } catch (std::out_of_range& e) {
58460       {
58461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58462       };
58463     } catch (std::exception& e) {
58464       {
58465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58466       };
58467     } catch (Dali::DaliException e) {
58468       {
58469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58470       };
58471     } catch (...) {
58472       {
58473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58474       };
58475     }
58476   }
58477
58478   jresult = (void *)result;
58479   return jresult;
58480 }
58481
58482
58483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
58484   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58485
58486   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58487   {
58488     try {
58489       delete arg1;
58490     } catch (std::out_of_range& e) {
58491       {
58492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58493       };
58494     } catch (std::exception& e) {
58495       {
58496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58497       };
58498     } catch (Dali::DaliException e) {
58499       {
58500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58501       };
58502     } catch (...) {
58503       {
58504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58505       };
58506     }
58507   }
58508
58509 }
58510
58511
58512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
58513   void * jresult ;
58514   Dali::Timer *result = 0 ;
58515
58516   {
58517     try {
58518       result = (Dali::Timer *)new Dali::Timer();
58519     } catch (std::out_of_range& e) {
58520       {
58521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58522       };
58523     } catch (std::exception& e) {
58524       {
58525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58526       };
58527     } catch (Dali::DaliException e) {
58528       {
58529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58530       };
58531     } catch (...) {
58532       {
58533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58534       };
58535     }
58536   }
58537
58538   jresult = (void *)result;
58539   return jresult;
58540 }
58541
58542
58543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
58544   void * jresult ;
58545   unsigned int arg1 ;
58546   Dali::Timer result;
58547
58548   arg1 = (unsigned int)jarg1;
58549   {
58550     try {
58551       result = Dali::Timer::New(arg1);
58552     } catch (std::out_of_range& e) {
58553       {
58554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58555       };
58556     } catch (std::exception& e) {
58557       {
58558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58559       };
58560     } catch (Dali::DaliException e) {
58561       {
58562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58563       };
58564     } catch (...) {
58565       {
58566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58567       };
58568     }
58569   }
58570
58571   jresult = new Dali::Timer((const Dali::Timer &)result);
58572   return jresult;
58573 }
58574
58575
58576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
58577   void * jresult ;
58578   Dali::Timer *arg1 = 0 ;
58579   Dali::Timer *result = 0 ;
58580
58581   arg1 = (Dali::Timer *)jarg1;
58582   if (!arg1) {
58583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58584     return 0;
58585   }
58586   {
58587     try {
58588       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
58589     } catch (std::out_of_range& e) {
58590       {
58591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58592       };
58593     } catch (std::exception& e) {
58594       {
58595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58596       };
58597     } catch (Dali::DaliException e) {
58598       {
58599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58600       };
58601     } catch (...) {
58602       {
58603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58604       };
58605     }
58606   }
58607
58608   jresult = (void *)result;
58609   return jresult;
58610 }
58611
58612
58613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
58614   void * jresult ;
58615   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58616   Dali::Timer *arg2 = 0 ;
58617   Dali::Timer *result = 0 ;
58618
58619   arg1 = (Dali::Timer *)jarg1;
58620   arg2 = (Dali::Timer *)jarg2;
58621   if (!arg2) {
58622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58623     return 0;
58624   }
58625   {
58626     try {
58627       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
58628     } catch (std::out_of_range& e) {
58629       {
58630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58631       };
58632     } catch (std::exception& e) {
58633       {
58634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58635       };
58636     } catch (Dali::DaliException e) {
58637       {
58638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58639       };
58640     } catch (...) {
58641       {
58642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58643       };
58644     }
58645   }
58646
58647   jresult = (void *)result;
58648   return jresult;
58649 }
58650
58651
58652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
58653   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58654
58655   arg1 = (Dali::Timer *)jarg1;
58656   {
58657     try {
58658       delete arg1;
58659     } catch (std::out_of_range& e) {
58660       {
58661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58662       };
58663     } catch (std::exception& e) {
58664       {
58665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58666       };
58667     } catch (Dali::DaliException e) {
58668       {
58669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58670       };
58671     } catch (...) {
58672       {
58673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58674       };
58675     }
58676   }
58677
58678 }
58679
58680
58681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
58682   void * jresult ;
58683   Dali::BaseHandle arg1 ;
58684   Dali::BaseHandle *argp1 ;
58685   Dali::Timer result;
58686
58687   argp1 = (Dali::BaseHandle *)jarg1;
58688   if (!argp1) {
58689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58690     return 0;
58691   }
58692   arg1 = *argp1;
58693   {
58694     try {
58695       result = Dali::Timer::DownCast(arg1);
58696     } catch (std::out_of_range& e) {
58697       {
58698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58699       };
58700     } catch (std::exception& e) {
58701       {
58702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58703       };
58704     } catch (Dali::DaliException e) {
58705       {
58706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58707       };
58708     } catch (...) {
58709       {
58710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58711       };
58712     }
58713   }
58714
58715   jresult = new Dali::Timer((const Dali::Timer &)result);
58716   return jresult;
58717 }
58718
58719
58720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
58721   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58722
58723   arg1 = (Dali::Timer *)jarg1;
58724   {
58725     try {
58726       (arg1)->Start();
58727     } catch (std::out_of_range& e) {
58728       {
58729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58730       };
58731     } catch (std::exception& e) {
58732       {
58733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58734       };
58735     } catch (Dali::DaliException e) {
58736       {
58737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58738       };
58739     } catch (...) {
58740       {
58741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58742       };
58743     }
58744   }
58745
58746 }
58747
58748
58749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
58750   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58751
58752   arg1 = (Dali::Timer *)jarg1;
58753   {
58754     try {
58755       (arg1)->Stop();
58756     } catch (std::out_of_range& e) {
58757       {
58758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58759       };
58760     } catch (std::exception& e) {
58761       {
58762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58763       };
58764     } catch (Dali::DaliException e) {
58765       {
58766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58767       };
58768     } catch (...) {
58769       {
58770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58771       };
58772     }
58773   }
58774
58775 }
58776
58777
58778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
58779   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58780   unsigned int arg2 ;
58781
58782   arg1 = (Dali::Timer *)jarg1;
58783   arg2 = (unsigned int)jarg2;
58784   {
58785     try {
58786       (arg1)->SetInterval(arg2);
58787     } catch (std::out_of_range& e) {
58788       {
58789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58790       };
58791     } catch (std::exception& e) {
58792       {
58793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58794       };
58795     } catch (Dali::DaliException e) {
58796       {
58797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58798       };
58799     } catch (...) {
58800       {
58801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58802       };
58803     }
58804   }
58805
58806 }
58807
58808
58809 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
58810   unsigned int jresult ;
58811   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58812   unsigned int result;
58813
58814   arg1 = (Dali::Timer *)jarg1;
58815   {
58816     try {
58817       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
58818     } catch (std::out_of_range& e) {
58819       {
58820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58821       };
58822     } catch (std::exception& e) {
58823       {
58824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58825       };
58826     } catch (Dali::DaliException e) {
58827       {
58828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58829       };
58830     } catch (...) {
58831       {
58832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58833       };
58834     }
58835   }
58836
58837   jresult = result;
58838   return jresult;
58839 }
58840
58841
58842 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
58843   unsigned int jresult ;
58844   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58845   bool result;
58846
58847   arg1 = (Dali::Timer *)jarg1;
58848   {
58849     try {
58850       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
58851     } catch (std::out_of_range& e) {
58852       {
58853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58854       };
58855     } catch (std::exception& e) {
58856       {
58857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58858       };
58859     } catch (Dali::DaliException e) {
58860       {
58861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58862       };
58863     } catch (...) {
58864       {
58865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58866       };
58867     }
58868   }
58869
58870   jresult = result;
58871   return jresult;
58872 }
58873
58874
58875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
58876   void * jresult ;
58877   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58878   Dali::Timer::TimerSignalType *result = 0 ;
58879
58880   arg1 = (Dali::Timer *)jarg1;
58881   {
58882     try {
58883       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
58884     } catch (std::out_of_range& e) {
58885       {
58886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58887       };
58888     } catch (std::exception& e) {
58889       {
58890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58891       };
58892     } catch (Dali::DaliException e) {
58893       {
58894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58895       };
58896     } catch (...) {
58897       {
58898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58899       };
58900     }
58901   }
58902
58903   jresult = (void *)result;
58904   return jresult;
58905 }
58906
58907
58908 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
58909   unsigned int jresult ;
58910   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58911   bool result;
58912
58913   arg1 = (Dali::Signal< bool () > *)jarg1;
58914   {
58915     try {
58916       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
58917     } catch (std::out_of_range& e) {
58918       {
58919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58920       };
58921     } catch (std::exception& e) {
58922       {
58923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58924       };
58925     } catch (Dali::DaliException e) {
58926       {
58927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58928       };
58929     } catch (...) {
58930       {
58931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58932       };
58933     }
58934   }
58935
58936   jresult = result;
58937   return jresult;
58938 }
58939
58940
58941 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
58942   unsigned long jresult ;
58943   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58944   std::size_t result;
58945
58946   arg1 = (Dali::Signal< bool () > *)jarg1;
58947   {
58948     try {
58949       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
58950     } catch (std::out_of_range& e) {
58951       {
58952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58953       };
58954     } catch (std::exception& e) {
58955       {
58956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58957       };
58958     } catch (Dali::DaliException e) {
58959       {
58960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58961       };
58962     } catch (...) {
58963       {
58964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58965       };
58966     }
58967   }
58968
58969   jresult = (unsigned long)result;
58970   return jresult;
58971 }
58972
58973
58974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
58975   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58976   bool (*arg2)() = (bool (*)()) 0 ;
58977
58978   arg1 = (Dali::Signal< bool () > *)jarg1;
58979   arg2 = (bool (*)())jarg2;
58980   {
58981     try {
58982       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
58983     } catch (std::out_of_range& e) {
58984       {
58985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58986       };
58987     } catch (std::exception& e) {
58988       {
58989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58990       };
58991     } catch (Dali::DaliException e) {
58992       {
58993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58994       };
58995     } catch (...) {
58996       {
58997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58998       };
58999     }
59000   }
59001
59002 }
59003
59004
59005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
59006   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59007   bool (*arg2)() = (bool (*)()) 0 ;
59008
59009   arg1 = (Dali::Signal< bool () > *)jarg1;
59010   arg2 = (bool (*)())jarg2;
59011   {
59012     try {
59013       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
59014     } catch (std::out_of_range& e) {
59015       {
59016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59017       };
59018     } catch (std::exception& e) {
59019       {
59020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59021       };
59022     } catch (Dali::DaliException e) {
59023       {
59024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59025       };
59026     } catch (...) {
59027       {
59028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59029       };
59030     }
59031   }
59032
59033 }
59034
59035
59036 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
59037   unsigned int jresult ;
59038   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59039   bool result;
59040
59041   arg1 = (Dali::Signal< bool () > *)jarg1;
59042   {
59043     try {
59044       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
59045     } catch (std::out_of_range& e) {
59046       {
59047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59048       };
59049     } catch (std::exception& e) {
59050       {
59051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59052       };
59053     } catch (Dali::DaliException e) {
59054       {
59055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59056       };
59057     } catch (...) {
59058       {
59059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59060       };
59061     }
59062   }
59063
59064   jresult = result;
59065   return jresult;
59066 }
59067
59068
59069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
59070   void * jresult ;
59071   Dali::Signal< bool () > *result = 0 ;
59072
59073   {
59074     try {
59075       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
59076     } catch (std::out_of_range& e) {
59077       {
59078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59079       };
59080     } catch (std::exception& e) {
59081       {
59082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59083       };
59084     } catch (Dali::DaliException e) {
59085       {
59086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59087       };
59088     } catch (...) {
59089       {
59090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59091       };
59092     }
59093   }
59094
59095   jresult = (void *)result;
59096   return jresult;
59097 }
59098
59099
59100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
59101   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59102
59103   arg1 = (Dali::Signal< bool () > *)jarg1;
59104   {
59105     try {
59106       delete arg1;
59107     } catch (std::out_of_range& e) {
59108       {
59109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59110       };
59111     } catch (std::exception& e) {
59112       {
59113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59114       };
59115     } catch (Dali::DaliException e) {
59116       {
59117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59118       };
59119     } catch (...) {
59120       {
59121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59122       };
59123     }
59124   }
59125
59126 }
59127
59128
59129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
59130   int jresult ;
59131   int result;
59132
59133   {
59134     try {
59135       result = (int)Dali::Toolkit::Visual::Property::TYPE;
59136     } catch (std::out_of_range& e) {
59137       {
59138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59139       };
59140     } catch (std::exception& e) {
59141       {
59142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59143       };
59144     } catch (Dali::DaliException e) {
59145       {
59146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59147       };
59148     } catch (...) {
59149       {
59150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59151       };
59152     }
59153   }
59154
59155   jresult = (int)result;
59156   return jresult;
59157 }
59158
59159
59160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
59161   int jresult ;
59162   int result;
59163
59164   {
59165     try {
59166       result = (int)Dali::Toolkit::Visual::Property::SHADER;
59167     } catch (std::out_of_range& e) {
59168       {
59169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59170       };
59171     } catch (std::exception& e) {
59172       {
59173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59174       };
59175     } catch (Dali::DaliException e) {
59176       {
59177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59178       };
59179     } catch (...) {
59180       {
59181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59182       };
59183     }
59184   }
59185
59186   jresult = (int)result;
59187   return jresult;
59188 }
59189
59190
59191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
59192   int jresult ;
59193   int result;
59194
59195   {
59196     try {
59197       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
59198     } catch (std::out_of_range& e) {
59199       {
59200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59201       };
59202     } catch (std::exception& e) {
59203       {
59204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59205       };
59206     } catch (Dali::DaliException e) {
59207       {
59208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59209       };
59210     } catch (...) {
59211       {
59212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59213       };
59214     }
59215   }
59216
59217   jresult = (int)result;
59218   return jresult;
59219 }
59220
59221
59222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
59223   int jresult ;
59224   int result;
59225
59226   {
59227     try {
59228       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
59229     } catch (std::out_of_range& e) {
59230       {
59231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59232       };
59233     } catch (std::exception& e) {
59234       {
59235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59236       };
59237     } catch (Dali::DaliException e) {
59238       {
59239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59240       };
59241     } catch (...) {
59242       {
59243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59244       };
59245     }
59246   }
59247
59248   jresult = (int)result;
59249   return jresult;
59250 }
59251
59252
59253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
59254   int jresult ;
59255   int result;
59256
59257   {
59258     try {
59259       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
59260     } catch (std::out_of_range& e) {
59261       {
59262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59263       };
59264     } catch (std::exception& e) {
59265       {
59266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59267       };
59268     } catch (Dali::DaliException e) {
59269       {
59270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59271       };
59272     } catch (...) {
59273       {
59274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59275       };
59276     }
59277   }
59278
59279   jresult = (int)result;
59280   return jresult;
59281 }
59282
59283
59284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
59285   int jresult ;
59286   int result;
59287
59288   {
59289     try {
59290       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
59291     } catch (std::out_of_range& e) {
59292       {
59293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59294       };
59295     } catch (std::exception& e) {
59296       {
59297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59298       };
59299     } catch (Dali::DaliException e) {
59300       {
59301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59302       };
59303     } catch (...) {
59304       {
59305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59306       };
59307     }
59308   }
59309
59310   jresult = (int)result;
59311   return jresult;
59312 }
59313
59314
59315 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
59316   int jresult ;
59317   int result;
59318
59319   {
59320     try {
59321       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
59322     } catch (std::out_of_range& e) {
59323       {
59324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59325       };
59326     } catch (std::exception& e) {
59327       {
59328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59329       };
59330     } catch (Dali::DaliException e) {
59331       {
59332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59333       };
59334     } catch (...) {
59335       {
59336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59337       };
59338     }
59339   }
59340
59341   jresult = (int)result;
59342   return jresult;
59343 }
59344
59345
59346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
59347   int jresult ;
59348   int result;
59349
59350   {
59351     try {
59352       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
59353     } catch (std::out_of_range& e) {
59354       {
59355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59356       };
59357     } catch (std::exception& e) {
59358       {
59359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59360       };
59361     } catch (Dali::DaliException e) {
59362       {
59363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59364       };
59365     } catch (...) {
59366       {
59367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59368       };
59369     }
59370   }
59371
59372   jresult = (int)result;
59373   return jresult;
59374 }
59375
59376
59377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
59378   int jresult ;
59379   int result;
59380
59381   {
59382     try {
59383       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
59384     } catch (std::out_of_range& e) {
59385       {
59386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59387       };
59388     } catch (std::exception& e) {
59389       {
59390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59391       };
59392     } catch (Dali::DaliException e) {
59393       {
59394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59395       };
59396     } catch (...) {
59397       {
59398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59399       };
59400     }
59401   }
59402
59403   jresult = (int)result;
59404   return jresult;
59405 }
59406
59407
59408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
59409   int jresult ;
59410   int result;
59411
59412   {
59413     try {
59414       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
59415     } catch (std::out_of_range& e) {
59416       {
59417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59418       };
59419     } catch (std::exception& e) {
59420       {
59421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59422       };
59423     } catch (Dali::DaliException e) {
59424       {
59425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59426       };
59427     } catch (...) {
59428       {
59429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59430       };
59431     }
59432   }
59433
59434   jresult = (int)result;
59435   return jresult;
59436 }
59437
59438
59439 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
59440   int jresult ;
59441   int result;
59442
59443   {
59444     try {
59445       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
59446     } catch (std::out_of_range& e) {
59447       {
59448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59449       };
59450     } catch (std::exception& e) {
59451       {
59452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59453       };
59454     } catch (Dali::DaliException e) {
59455       {
59456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59457       };
59458     } catch (...) {
59459       {
59460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59461       };
59462     }
59463   }
59464
59465   jresult = (int)result;
59466   return jresult;
59467 }
59468
59469
59470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
59471   int jresult ;
59472   int result;
59473
59474   {
59475     try {
59476       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
59477     } catch (std::out_of_range& e) {
59478       {
59479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59480       };
59481     } catch (std::exception& e) {
59482       {
59483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59484       };
59485     } catch (Dali::DaliException e) {
59486       {
59487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59488       };
59489     } catch (...) {
59490       {
59491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59492       };
59493     }
59494   }
59495
59496   jresult = (int)result;
59497   return jresult;
59498 }
59499
59500
59501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
59502   int jresult ;
59503   int result;
59504
59505   {
59506     try {
59507       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
59508     } catch (std::out_of_range& e) {
59509       {
59510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59511       };
59512     } catch (std::exception& e) {
59513       {
59514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59515       };
59516     } catch (Dali::DaliException e) {
59517       {
59518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59519       };
59520     } catch (...) {
59521       {
59522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59523       };
59524     }
59525   }
59526
59527   jresult = (int)result;
59528   return jresult;
59529 }
59530
59531
59532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
59533   int jresult ;
59534   int result;
59535
59536   {
59537     try {
59538       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
59539     } catch (std::out_of_range& e) {
59540       {
59541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59542       };
59543     } catch (std::exception& e) {
59544       {
59545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59546       };
59547     } catch (Dali::DaliException e) {
59548       {
59549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59550       };
59551     } catch (...) {
59552       {
59553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59554       };
59555     }
59556   }
59557
59558   jresult = (int)result;
59559   return jresult;
59560 }
59561
59562
59563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
59564   int jresult ;
59565   int result;
59566
59567   {
59568     try {
59569       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
59570     } catch (std::out_of_range& e) {
59571       {
59572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59573       };
59574     } catch (std::exception& e) {
59575       {
59576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59577       };
59578     } catch (Dali::DaliException e) {
59579       {
59580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59581       };
59582     } catch (...) {
59583       {
59584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59585       };
59586     }
59587   }
59588
59589   jresult = (int)result;
59590   return jresult;
59591 }
59592
59593
59594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
59595   int jresult ;
59596   int result;
59597
59598   {
59599     try {
59600       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
59601     } catch (std::out_of_range& e) {
59602       {
59603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59604       };
59605     } catch (std::exception& e) {
59606       {
59607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59608       };
59609     } catch (Dali::DaliException e) {
59610       {
59611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59612       };
59613     } catch (...) {
59614       {
59615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59616       };
59617     }
59618   }
59619
59620   jresult = (int)result;
59621   return jresult;
59622 }
59623
59624
59625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
59626   int jresult ;
59627   int result;
59628
59629   {
59630     try {
59631       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
59632     } catch (std::out_of_range& e) {
59633       {
59634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59635       };
59636     } catch (std::exception& e) {
59637       {
59638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59639       };
59640     } catch (Dali::DaliException e) {
59641       {
59642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59643       };
59644     } catch (...) {
59645       {
59646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59647       };
59648     }
59649   }
59650
59651   jresult = (int)result;
59652   return jresult;
59653 }
59654
59655
59656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
59657   int jresult ;
59658   int result;
59659
59660   {
59661     try {
59662       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
59663     } catch (std::out_of_range& e) {
59664       {
59665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59666       };
59667     } catch (std::exception& e) {
59668       {
59669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59670       };
59671     } catch (Dali::DaliException e) {
59672       {
59673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59674       };
59675     } catch (...) {
59676       {
59677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59678       };
59679     }
59680   }
59681
59682   jresult = (int)result;
59683   return jresult;
59684 }
59685
59686
59687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
59688   int jresult ;
59689   int result;
59690
59691   {
59692     try {
59693       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
59694     } catch (std::out_of_range& e) {
59695       {
59696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59697       };
59698     } catch (std::exception& e) {
59699       {
59700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59701       };
59702     } catch (Dali::DaliException e) {
59703       {
59704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59705       };
59706     } catch (...) {
59707       {
59708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59709       };
59710     }
59711   }
59712
59713   jresult = (int)result;
59714   return jresult;
59715 }
59716
59717
59718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
59719   int jresult ;
59720   int result;
59721
59722   {
59723     try {
59724       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
59725     } catch (std::out_of_range& e) {
59726       {
59727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59728       };
59729     } catch (std::exception& e) {
59730       {
59731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59732       };
59733     } catch (Dali::DaliException e) {
59734       {
59735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59736       };
59737     } catch (...) {
59738       {
59739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59740       };
59741     }
59742   }
59743
59744   jresult = (int)result;
59745   return jresult;
59746 }
59747
59748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
59749   int jresult ;
59750   int result;
59751
59752   {
59753     try {
59754       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
59755     } catch (std::out_of_range& e) {
59756       {
59757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59758       };
59759     } catch (std::exception& e) {
59760       {
59761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59762       };
59763     } catch (Dali::DaliException e) {
59764       {
59765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59766       };
59767     } catch (...) {
59768       {
59769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59770       };
59771     }
59772   }
59773
59774   jresult = (int)result;
59775   return jresult;
59776 }
59777
59778
59779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
59780   int jresult ;
59781   int result;
59782   {
59783     try
59784     {
59785       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
59786     } catch (std::out_of_range& e) {
59787       {
59788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59789       };
59790     } catch (std::exception& e) {
59791       {
59792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59793       };
59794     } catch (Dali::DaliException e) {
59795       {
59796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59797       };
59798     } catch (...) {
59799       {
59800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59801       };
59802     }
59803   }
59804
59805   jresult = (int)result;
59806   return jresult;
59807 }
59808
59809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
59810   int jresult ;
59811   int result;
59812   {
59813     try
59814     {
59815       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
59816     } catch (std::out_of_range& e) {
59817       {
59818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59819       };
59820     } catch (std::exception& e) {
59821       {
59822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59823       };
59824     } catch (Dali::DaliException e) {
59825       {
59826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59827       };
59828     } catch (...) {
59829       {
59830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59831       };
59832     }
59833   }
59834
59835   jresult = (int)result;
59836   return jresult;
59837 }
59838
59839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
59840   int jresult ;
59841   int result;
59842   {
59843     try
59844     {
59845       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
59846     } catch (std::out_of_range& e) {
59847       {
59848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59849       };
59850     } catch (std::exception& e) {
59851       {
59852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59853       };
59854     } catch (Dali::DaliException e) {
59855       {
59856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59857       };
59858     } catch (...) {
59859       {
59860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59861       };
59862     }
59863   }
59864
59865   jresult = (int)result;
59866   return jresult;
59867 }
59868
59869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
59870   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
59871 }
59872
59873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
59874   int jresult ;
59875   int result;
59876   {
59877     try
59878     {
59879       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
59880     } catch (std::out_of_range& e) {
59881       {
59882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59883       };
59884     } catch (std::exception& e) {
59885       {
59886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59887       };
59888     } catch (Dali::DaliException e) {
59889       {
59890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59891       };
59892     } catch (...) {
59893       {
59894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59895       };
59896     }
59897   }
59898
59899   jresult = (int)result;
59900   return jresult;
59901 }
59902
59903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
59904   int jresult ;
59905   int result;
59906   {
59907     try
59908     {
59909       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
59910     } catch (std::out_of_range& e) {
59911       {
59912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59913       };
59914     } catch (std::exception& e) {
59915       {
59916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59917       };
59918     } catch (Dali::DaliException e) {
59919       {
59920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59921       };
59922     } catch (...) {
59923       {
59924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59925       };
59926     }
59927   }
59928
59929   jresult = (int)result;
59930   return jresult;
59931 }
59932
59933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
59934   int jresult ;
59935   int result;
59936
59937   {
59938     try {
59939       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
59940     } catch (std::out_of_range& e) {
59941       {
59942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59943       };
59944     } catch (std::exception& e) {
59945       {
59946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59947       };
59948     } catch (Dali::DaliException e) {
59949       {
59950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59951       };
59952     } catch (...) {
59953       {
59954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59955       };
59956     }
59957   }
59958
59959   jresult = (int)result;
59960   return jresult;
59961 }
59962
59963
59964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
59965   int jresult ;
59966   int result;
59967
59968   {
59969     try {
59970       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
59971     } catch (std::out_of_range& e) {
59972       {
59973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59974       };
59975     } catch (std::exception& e) {
59976       {
59977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59978       };
59979     } catch (Dali::DaliException e) {
59980       {
59981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59982       };
59983     } catch (...) {
59984       {
59985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59986       };
59987     }
59988   }
59989
59990   jresult = (int)result;
59991   return jresult;
59992 }
59993
59994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
59995   int jresult ;
59996   int result;
59997   {
59998     try
59999     {
60000       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
60001     } catch (std::out_of_range& e) {
60002       {
60003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60004       };
60005     } catch (std::exception& e) {
60006       {
60007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60008       };
60009     } catch (...) {
60010       {
60011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60012       };
60013     }
60014   }
60015   jresult = (int)result;
60016   return jresult;
60017 }
60018
60019 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
60020   int jresult ;
60021   int result;
60022   {
60023     try
60024     {
60025       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
60026     } catch (std::out_of_range& e) {
60027       {
60028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60029       };
60030     } catch (std::exception& e) {
60031       {
60032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60033       };
60034     } catch (...) {
60035       {
60036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60037       };
60038     }
60039   }
60040   jresult = (int)result;
60041   return jresult;
60042 }
60043
60044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
60045   int jresult ;
60046   int result;
60047   {
60048     try
60049     {
60050       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
60051     } catch (std::out_of_range& e) {
60052       {
60053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60054       };
60055     } catch (std::exception& e) {
60056       {
60057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60058       };
60059     } catch (...) {
60060       {
60061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60062       };
60063     }
60064   }
60065   jresult = (int)result;
60066   return jresult;
60067 }
60068
60069
60070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
60071   int jresult ;
60072   int result;
60073   {
60074     try
60075     {
60076       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
60077     } catch (std::out_of_range& e) {
60078       {
60079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60080       };
60081     } catch (std::exception& e) {
60082       {
60083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60084       };
60085     } catch (...) {
60086       {
60087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60088       };
60089     }
60090   }
60091   jresult = (int)result;
60092   return jresult;
60093 }
60094
60095 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
60096   int jresult ;
60097   int result;
60098   {
60099     try
60100     {
60101       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
60102     } catch (std::out_of_range& e) {
60103       {
60104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60105       };
60106     } catch (std::exception& e) {
60107       {
60108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60109       };
60110     } catch (...) {
60111       {
60112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60113       };
60114     }
60115   }
60116   jresult = (int)result;
60117   return jresult;
60118 }
60119
60120
60121
60122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
60123   int jresult ;
60124   int result;
60125
60126   {
60127     try {
60128       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
60129     } catch (std::out_of_range& e) {
60130       {
60131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60132       };
60133     } catch (std::exception& e) {
60134       {
60135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60136       };
60137     } catch (Dali::DaliException e) {
60138       {
60139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60140       };
60141     } catch (...) {
60142       {
60143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60144       };
60145     }
60146   }
60147
60148   jresult = (int)result;
60149   return jresult;
60150 }
60151
60152
60153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
60154   int jresult ;
60155   int result;
60156
60157   {
60158     try {
60159       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
60160     } catch (std::out_of_range& e) {
60161       {
60162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60163       };
60164     } catch (std::exception& e) {
60165       {
60166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60167       };
60168     } catch (Dali::DaliException e) {
60169       {
60170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60171       };
60172     } catch (...) {
60173       {
60174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60175       };
60176     }
60177   }
60178
60179   jresult = (int)result;
60180   return jresult;
60181 }
60182
60183
60184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
60185   int jresult ;
60186   int result;
60187
60188   {
60189     try {
60190       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
60191     } catch (std::out_of_range& e) {
60192       {
60193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60194       };
60195     } catch (std::exception& e) {
60196       {
60197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60198       };
60199     } catch (Dali::DaliException e) {
60200       {
60201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60202       };
60203     } catch (...) {
60204       {
60205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60206       };
60207     }
60208   }
60209
60210   jresult = (int)result;
60211   return jresult;
60212 }
60213
60214
60215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
60216   int jresult ;
60217   int result;
60218
60219   {
60220     try {
60221       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
60222     } catch (std::out_of_range& e) {
60223       {
60224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60225       };
60226     } catch (std::exception& e) {
60227       {
60228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60229       };
60230     } catch (Dali::DaliException e) {
60231       {
60232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60233       };
60234     } catch (...) {
60235       {
60236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60237       };
60238     }
60239   }
60240
60241   jresult = (int)result;
60242   return jresult;
60243 }
60244
60245
60246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
60247   int jresult ;
60248   int result;
60249
60250   {
60251     try {
60252       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
60253     } catch (std::out_of_range& e) {
60254       {
60255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60256       };
60257     } catch (std::exception& e) {
60258       {
60259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60260       };
60261     } catch (Dali::DaliException e) {
60262       {
60263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60264       };
60265     } catch (...) {
60266       {
60267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60268       };
60269     }
60270   }
60271
60272   jresult = (int)result;
60273   return jresult;
60274 }
60275
60276
60277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
60278   int jresult ;
60279   int result;
60280
60281   {
60282     try {
60283       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
60284     } catch (std::out_of_range& e) {
60285       {
60286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60287       };
60288     } catch (std::exception& e) {
60289       {
60290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60291       };
60292     } catch (Dali::DaliException e) {
60293       {
60294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60295       };
60296     } catch (...) {
60297       {
60298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60299       };
60300     }
60301   }
60302
60303   jresult = (int)result;
60304   return jresult;
60305 }
60306
60307
60308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
60309   int jresult ;
60310   int result;
60311
60312   {
60313     try {
60314       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
60315     } catch (std::out_of_range& e) {
60316       {
60317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60318       };
60319     } catch (std::exception& e) {
60320       {
60321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60322       };
60323     } catch (Dali::DaliException e) {
60324       {
60325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60326       };
60327     } catch (...) {
60328       {
60329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60330       };
60331     }
60332   }
60333
60334   jresult = (int)result;
60335   return jresult;
60336 }
60337
60338 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
60339   int jresult ;
60340   int result;
60341
60342   {
60343     try {
60344       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
60345     } catch (std::out_of_range& e) {
60346       {
60347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60348       };
60349     } catch (std::exception& e) {
60350       {
60351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60352       };
60353     } catch (...) {
60354       {
60355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60356       };
60357     }
60358   }
60359   jresult = (int)result;
60360   return jresult;
60361 }
60362
60363 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
60364   int jresult ;
60365   int result;
60366
60367   {
60368     try {
60369       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
60370     } catch (std::out_of_range& e) {
60371       {
60372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60373       };
60374     } catch (std::exception& e) {
60375       {
60376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60377       };
60378     } catch (Dali::DaliException e) {
60379       {
60380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60381       };
60382     } catch (...) {
60383       {
60384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60385       };
60386     }
60387   }
60388
60389   jresult = (int)result;
60390   return jresult;
60391 }
60392
60393
60394 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
60395   int jresult ;
60396   int result;
60397
60398   {
60399     try {
60400       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
60401     } catch (std::out_of_range& e) {
60402       {
60403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60404       };
60405     } catch (std::exception& e) {
60406       {
60407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60408       };
60409     } catch (Dali::DaliException e) {
60410       {
60411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60412       };
60413     } catch (...) {
60414       {
60415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60416       };
60417     }
60418   }
60419
60420   jresult = (int)result;
60421   return jresult;
60422 }
60423
60424
60425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
60426   int jresult ;
60427   int result;
60428
60429   {
60430     try {
60431       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
60432     } catch (std::out_of_range& e) {
60433       {
60434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60435       };
60436     } catch (std::exception& e) {
60437       {
60438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60439       };
60440     } catch (Dali::DaliException e) {
60441       {
60442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60443       };
60444     } catch (...) {
60445       {
60446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60447       };
60448     }
60449   }
60450
60451   jresult = (int)result;
60452   return jresult;
60453 }
60454
60455
60456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
60457   int jresult ;
60458   int result;
60459
60460   {
60461     try {
60462       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
60463     } catch (std::out_of_range& e) {
60464       {
60465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60466       };
60467     } catch (std::exception& e) {
60468       {
60469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60470       };
60471     } catch (Dali::DaliException e) {
60472       {
60473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60474       };
60475     } catch (...) {
60476       {
60477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60478       };
60479     }
60480   }
60481
60482   jresult = (int)result;
60483   return jresult;
60484 }
60485
60486
60487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
60488   int jresult ;
60489   int result;
60490
60491   {
60492     try {
60493       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
60494     } catch (std::out_of_range& e) {
60495       {
60496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60497       };
60498     } catch (std::exception& e) {
60499       {
60500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60501       };
60502     } catch (Dali::DaliException e) {
60503       {
60504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60505       };
60506     } catch (...) {
60507       {
60508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60509       };
60510     }
60511   }
60512
60513   jresult = (int)result;
60514   return jresult;
60515 }
60516
60517
60518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
60519   int jresult ;
60520   int result;
60521
60522   {
60523     try {
60524       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
60525     } catch (std::out_of_range& e) {
60526       {
60527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60528       };
60529     } catch (std::exception& e) {
60530       {
60531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60532       };
60533     } catch (Dali::DaliException e) {
60534       {
60535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60536       };
60537     } catch (...) {
60538       {
60539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60540       };
60541     }
60542   }
60543
60544   jresult = (int)result;
60545   return jresult;
60546 }
60547
60548
60549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
60550   int jresult ;
60551   int result;
60552
60553   {
60554     try {
60555       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
60556     } catch (std::out_of_range& e) {
60557       {
60558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60559       };
60560     } catch (std::exception& e) {
60561       {
60562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60563       };
60564     } catch (Dali::DaliException e) {
60565       {
60566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60567       };
60568     } catch (...) {
60569       {
60570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60571       };
60572     }
60573   }
60574
60575   jresult = (int)result;
60576   return jresult;
60577 }
60578
60579
60580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
60581   int jresult ;
60582   int result;
60583
60584   {
60585     try {
60586       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
60587     } catch (std::out_of_range& e) {
60588       {
60589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60590       };
60591     } catch (std::exception& e) {
60592       {
60593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60594       };
60595     } catch (Dali::DaliException e) {
60596       {
60597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60598       };
60599     } catch (...) {
60600       {
60601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60602       };
60603     }
60604   }
60605
60606   jresult = (int)result;
60607   return jresult;
60608 }
60609
60610
60611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
60612   int jresult ;
60613   int result;
60614
60615   {
60616     try {
60617       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
60618     } catch (std::out_of_range& e) {
60619       {
60620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60621       };
60622     } catch (std::exception& e) {
60623       {
60624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60625       };
60626     } catch (Dali::DaliException e) {
60627       {
60628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60629       };
60630     } catch (...) {
60631       {
60632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60633       };
60634     }
60635   }
60636
60637   jresult = (int)result;
60638   return jresult;
60639 }
60640
60641
60642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
60643   int jresult ;
60644   int result;
60645
60646   {
60647     try {
60648       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
60649     } catch (std::out_of_range& e) {
60650       {
60651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60652       };
60653     } catch (std::exception& e) {
60654       {
60655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60656       };
60657     } catch (Dali::DaliException e) {
60658       {
60659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60660       };
60661     } catch (...) {
60662       {
60663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60664       };
60665     }
60666   }
60667
60668   jresult = (int)result;
60669   return jresult;
60670 }
60671
60672
60673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
60674   int jresult ;
60675   int result;
60676
60677   {
60678     try {
60679       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
60680     } catch (std::out_of_range& e) {
60681       {
60682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60683       };
60684     } catch (std::exception& e) {
60685       {
60686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60687       };
60688     } catch (Dali::DaliException e) {
60689       {
60690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60691       };
60692     } catch (...) {
60693       {
60694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60695       };
60696     }
60697   }
60698
60699   jresult = (int)result;
60700   return jresult;
60701 }
60702
60703
60704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
60705   int jresult ;
60706   int result;
60707
60708   {
60709     try {
60710       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
60711     } catch (std::out_of_range& e) {
60712       {
60713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60714       };
60715     } catch (std::exception& e) {
60716       {
60717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60718       };
60719     } catch (Dali::DaliException e) {
60720       {
60721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60722       };
60723     } catch (...) {
60724       {
60725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60726       };
60727     }
60728   }
60729
60730   jresult = (int)result;
60731   return jresult;
60732 }
60733
60734
60735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
60736   int jresult ;
60737   int result;
60738
60739   {
60740     try {
60741       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
60742     } catch (std::out_of_range& e) {
60743       {
60744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60745       };
60746     } catch (std::exception& e) {
60747       {
60748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60749       };
60750     } catch (Dali::DaliException e) {
60751       {
60752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60753       };
60754     } catch (...) {
60755       {
60756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60757       };
60758     }
60759   }
60760
60761   jresult = (int)result;
60762   return jresult;
60763 }
60764
60765
60766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
60767   int jresult ;
60768   int result;
60769
60770   {
60771     try {
60772       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
60773     } catch (std::out_of_range& e) {
60774       {
60775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60776       };
60777     } catch (std::exception& e) {
60778       {
60779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60780       };
60781     } catch (Dali::DaliException e) {
60782       {
60783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60784       };
60785     } catch (...) {
60786       {
60787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60788       };
60789     }
60790   }
60791
60792   jresult = (int)result;
60793   return jresult;
60794 }
60795
60796
60797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
60798   int jresult ;
60799   int result;
60800
60801   {
60802     try {
60803       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
60804     } catch (std::out_of_range& e) {
60805       {
60806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60807       };
60808     } catch (std::exception& e) {
60809       {
60810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60811       };
60812     } catch (Dali::DaliException e) {
60813       {
60814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60815       };
60816     } catch (...) {
60817       {
60818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60819       };
60820     }
60821   }
60822
60823   jresult = (int)result;
60824   return jresult;
60825 }
60826
60827
60828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
60829   int jresult ;
60830   int result;
60831
60832   {
60833     try {
60834       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
60835     } catch (std::out_of_range& e) {
60836       {
60837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60838       };
60839     } catch (std::exception& e) {
60840       {
60841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60842       };
60843     } catch (Dali::DaliException e) {
60844       {
60845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60846       };
60847     } catch (...) {
60848       {
60849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60850       };
60851     }
60852   }
60853
60854   jresult = (int)result;
60855   return jresult;
60856 }
60857
60858
60859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
60860   int jresult ;
60861   int result;
60862
60863   {
60864     try {
60865       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
60866     } catch (std::out_of_range& e) {
60867       {
60868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60869       };
60870     } catch (std::exception& e) {
60871       {
60872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60873       };
60874     } catch (Dali::DaliException e) {
60875       {
60876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60877       };
60878     } catch (...) {
60879       {
60880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60881       };
60882     }
60883   }
60884
60885   jresult = (int)result;
60886   return jresult;
60887 }
60888
60889
60890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
60891   int jresult ;
60892   int result;
60893
60894   {
60895     try {
60896       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
60897     } catch (std::out_of_range& e) {
60898       {
60899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60900       };
60901     } catch (std::exception& e) {
60902       {
60903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60904       };
60905     } catch (Dali::DaliException e) {
60906       {
60907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60908       };
60909     } catch (...) {
60910       {
60911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60912       };
60913     }
60914   }
60915
60916   jresult = (int)result;
60917   return jresult;
60918 }
60919
60920
60921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
60922   int jresult ;
60923   int result;
60924
60925   {
60926     try {
60927       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
60928     } catch (std::out_of_range& e) {
60929       {
60930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60931       };
60932     } catch (std::exception& e) {
60933       {
60934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60935       };
60936     } catch (Dali::DaliException e) {
60937       {
60938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60939       };
60940     } catch (...) {
60941       {
60942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60943       };
60944     }
60945   }
60946
60947   jresult = (int)result;
60948   return jresult;
60949 }
60950
60951
60952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
60953   int jresult ;
60954   int result;
60955
60956   {
60957     try {
60958       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
60959     } catch (std::out_of_range& e) {
60960       {
60961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60962       };
60963     } catch (std::exception& e) {
60964       {
60965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60966       };
60967     } catch (Dali::DaliException e) {
60968       {
60969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60970       };
60971     } catch (...) {
60972       {
60973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60974       };
60975     }
60976   }
60977
60978   jresult = (int)result;
60979   return jresult;
60980 }
60981
60982
60983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
60984   int jresult ;
60985   int result;
60986
60987   {
60988     try {
60989       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
60990     } catch (std::out_of_range& e) {
60991       {
60992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60993       };
60994     } catch (std::exception& e) {
60995       {
60996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60997       };
60998     } catch (Dali::DaliException e) {
60999       {
61000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61001       };
61002     } catch (...) {
61003       {
61004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61005       };
61006     }
61007   }
61008
61009   jresult = (int)result;
61010   return jresult;
61011 }
61012
61013
61014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
61015   int jresult ;
61016   int result;
61017
61018   {
61019     try {
61020       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
61021     } catch (std::out_of_range& e) {
61022       {
61023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61024       };
61025     } catch (std::exception& e) {
61026       {
61027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61028       };
61029     } catch (Dali::DaliException e) {
61030       {
61031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61032       };
61033     } catch (...) {
61034       {
61035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61036       };
61037     }
61038   }
61039
61040   jresult = (int)result;
61041   return jresult;
61042 }
61043
61044
61045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
61046   int jresult ;
61047   int result;
61048
61049   {
61050     try {
61051       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
61052     } catch (std::out_of_range& e) {
61053       {
61054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61055       };
61056     } catch (std::exception& e) {
61057       {
61058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61059       };
61060     } catch (Dali::DaliException e) {
61061       {
61062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61063       };
61064     } catch (...) {
61065       {
61066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61067       };
61068     }
61069   }
61070
61071   jresult = (int)result;
61072   return jresult;
61073 }
61074
61075
61076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
61077   int jresult ;
61078   int result;
61079
61080   {
61081     try {
61082       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
61083     } catch (std::out_of_range& e) {
61084       {
61085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61086       };
61087     } catch (std::exception& e) {
61088       {
61089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61090       };
61091     } catch (Dali::DaliException e) {
61092       {
61093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61094       };
61095     } catch (...) {
61096       {
61097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61098       };
61099     }
61100   }
61101
61102   jresult = (int)result;
61103   return jresult;
61104 }
61105
61106
61107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
61108   int jresult ;
61109   int result;
61110
61111   {
61112     try {
61113       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
61114     } catch (std::out_of_range& e) {
61115       {
61116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61117       };
61118     } catch (std::exception& e) {
61119       {
61120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61121       };
61122     } catch (Dali::DaliException e) {
61123       {
61124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61125       };
61126     } catch (...) {
61127       {
61128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61129       };
61130     }
61131   }
61132
61133   jresult = (int)result;
61134   return jresult;
61135 }
61136
61137
61138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
61139   int jresult ;
61140   int result;
61141
61142   {
61143     try {
61144       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
61145     } catch (std::out_of_range& e) {
61146       {
61147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61148       };
61149     } catch (std::exception& e) {
61150       {
61151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61152       };
61153     } catch (Dali::DaliException e) {
61154       {
61155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61156       };
61157     } catch (...) {
61158       {
61159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61160       };
61161     }
61162   }
61163
61164   jresult = (int)result;
61165   return jresult;
61166 }
61167
61168
61169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
61170   int jresult ;
61171   int result;
61172
61173   {
61174     try {
61175       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
61176     } catch (std::out_of_range& e) {
61177       {
61178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61179       };
61180     } catch (std::exception& e) {
61181       {
61182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61183       };
61184     } catch (Dali::DaliException e) {
61185       {
61186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61187       };
61188     } catch (...) {
61189       {
61190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61191       };
61192     }
61193   }
61194
61195   jresult = (int)result;
61196   return jresult;
61197 }
61198
61199
61200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
61201   int jresult ;
61202   int result;
61203
61204   {
61205     try {
61206       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
61207     } catch (std::out_of_range& e) {
61208       {
61209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61210       };
61211     } catch (std::exception& e) {
61212       {
61213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61214       };
61215     } catch (Dali::DaliException e) {
61216       {
61217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61218       };
61219     } catch (...) {
61220       {
61221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61222       };
61223     }
61224   }
61225
61226   jresult = (int)result;
61227   return jresult;
61228 }
61229
61230
61231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
61232   void * jresult ;
61233   Dali::Toolkit::Builder *result = 0 ;
61234
61235   {
61236     try {
61237       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
61238     } catch (std::out_of_range& e) {
61239       {
61240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61241       };
61242     } catch (std::exception& e) {
61243       {
61244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61245       };
61246     } catch (Dali::DaliException e) {
61247       {
61248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61249       };
61250     } catch (...) {
61251       {
61252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61253       };
61254     }
61255   }
61256
61257   jresult = (void *)result;
61258   return jresult;
61259 }
61260
61261
61262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
61263   void * jresult ;
61264   Dali::Toolkit::Builder result;
61265
61266   {
61267     try {
61268       result = Dali::Toolkit::Builder::New();
61269     } catch (std::out_of_range& e) {
61270       {
61271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61272       };
61273     } catch (std::exception& e) {
61274       {
61275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61276       };
61277     } catch (Dali::DaliException e) {
61278       {
61279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61280       };
61281     } catch (...) {
61282       {
61283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61284       };
61285     }
61286   }
61287
61288   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
61289   return jresult;
61290 }
61291
61292
61293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
61294   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61295
61296   arg1 = (Dali::Toolkit::Builder *)jarg1;
61297   {
61298     try {
61299       delete arg1;
61300     } catch (std::out_of_range& e) {
61301       {
61302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61303       };
61304     } catch (std::exception& e) {
61305       {
61306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61307       };
61308     } catch (Dali::DaliException e) {
61309       {
61310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61311       };
61312     } catch (...) {
61313       {
61314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61315       };
61316     }
61317   }
61318
61319 }
61320
61321
61322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
61323   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61324   std::string *arg2 = 0 ;
61325   Dali::Toolkit::Builder::UIFormat arg3 ;
61326
61327   arg1 = (Dali::Toolkit::Builder *)jarg1;
61328   if (!jarg2) {
61329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61330     return ;
61331   }
61332   std::string arg2_str(jarg2);
61333   arg2 = &arg2_str;
61334   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
61335   {
61336     try {
61337       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
61338     } catch (std::out_of_range& e) {
61339       {
61340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61341       };
61342     } catch (std::exception& e) {
61343       {
61344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61345       };
61346     } catch (Dali::DaliException e) {
61347       {
61348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61349       };
61350     } catch (...) {
61351       {
61352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61353       };
61354     }
61355   }
61356
61357
61358   //argout typemap for const std::string&
61359
61360 }
61361
61362
61363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
61364   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61365   std::string *arg2 = 0 ;
61366
61367   arg1 = (Dali::Toolkit::Builder *)jarg1;
61368   if (!jarg2) {
61369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61370     return ;
61371   }
61372   std::string arg2_str(jarg2);
61373   arg2 = &arg2_str;
61374   {
61375     try {
61376       (arg1)->LoadFromString((std::string const &)*arg2);
61377     } catch (std::out_of_range& e) {
61378       {
61379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61380       };
61381     } catch (std::exception& e) {
61382       {
61383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61384       };
61385     } catch (Dali::DaliException e) {
61386       {
61387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61388       };
61389     } catch (...) {
61390       {
61391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61392       };
61393     }
61394   }
61395
61396
61397   //argout typemap for const std::string&
61398
61399 }
61400
61401
61402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
61403   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61404   Dali::Property::Map *arg2 = 0 ;
61405
61406   arg1 = (Dali::Toolkit::Builder *)jarg1;
61407   arg2 = (Dali::Property::Map *)jarg2;
61408   if (!arg2) {
61409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61410     return ;
61411   }
61412   {
61413     try {
61414       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
61415     } catch (std::out_of_range& e) {
61416       {
61417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61418       };
61419     } catch (std::exception& e) {
61420       {
61421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61422       };
61423     } catch (Dali::DaliException e) {
61424       {
61425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61426       };
61427     } catch (...) {
61428       {
61429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61430       };
61431     }
61432   }
61433
61434 }
61435
61436
61437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
61438   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61439   std::string *arg2 = 0 ;
61440   Dali::Property::Value *arg3 = 0 ;
61441
61442   arg1 = (Dali::Toolkit::Builder *)jarg1;
61443   if (!jarg2) {
61444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61445     return ;
61446   }
61447   std::string arg2_str(jarg2);
61448   arg2 = &arg2_str;
61449   arg3 = (Dali::Property::Value *)jarg3;
61450   if (!arg3) {
61451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
61452     return ;
61453   }
61454   {
61455     try {
61456       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
61457     } catch (std::out_of_range& e) {
61458       {
61459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61460       };
61461     } catch (std::exception& e) {
61462       {
61463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61464       };
61465     } catch (Dali::DaliException e) {
61466       {
61467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61468       };
61469     } catch (...) {
61470       {
61471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61472       };
61473     }
61474   }
61475
61476
61477   //argout typemap for const std::string&
61478
61479 }
61480
61481
61482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
61483   void * jresult ;
61484   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61485   Dali::Property::Map *result = 0 ;
61486
61487   arg1 = (Dali::Toolkit::Builder *)jarg1;
61488   {
61489     try {
61490       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
61491     } catch (std::out_of_range& e) {
61492       {
61493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61494       };
61495     } catch (std::exception& e) {
61496       {
61497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61498       };
61499     } catch (Dali::DaliException e) {
61500       {
61501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61502       };
61503     } catch (...) {
61504       {
61505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61506       };
61507     }
61508   }
61509
61510   jresult = (void *)result;
61511   return jresult;
61512 }
61513
61514
61515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
61516   void * jresult ;
61517   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61518   std::string *arg2 = 0 ;
61519   Dali::Property::Value *result = 0 ;
61520
61521   arg1 = (Dali::Toolkit::Builder *)jarg1;
61522   if (!jarg2) {
61523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61524     return 0;
61525   }
61526   std::string arg2_str(jarg2);
61527   arg2 = &arg2_str;
61528   {
61529     try {
61530       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
61531     } catch (std::out_of_range& e) {
61532       {
61533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61534       };
61535     } catch (std::exception& e) {
61536       {
61537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61538       };
61539     } catch (Dali::DaliException e) {
61540       {
61541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61542       };
61543     } catch (...) {
61544       {
61545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61546       };
61547     }
61548   }
61549
61550   jresult = (void *)result;
61551
61552   //argout typemap for const std::string&
61553
61554   return jresult;
61555 }
61556
61557
61558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
61559   void * jresult ;
61560   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61561   std::string *arg2 = 0 ;
61562   Dali::Animation result;
61563
61564   arg1 = (Dali::Toolkit::Builder *)jarg1;
61565   if (!jarg2) {
61566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61567     return 0;
61568   }
61569   std::string arg2_str(jarg2);
61570   arg2 = &arg2_str;
61571   {
61572     try {
61573       result = (arg1)->CreateAnimation((std::string const &)*arg2);
61574     } catch (std::out_of_range& e) {
61575       {
61576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61577       };
61578     } catch (std::exception& e) {
61579       {
61580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61581       };
61582     } catch (Dali::DaliException e) {
61583       {
61584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61585       };
61586     } catch (...) {
61587       {
61588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61589       };
61590     }
61591   }
61592
61593   jresult = new Dali::Animation((const Dali::Animation &)result);
61594
61595   //argout typemap for const std::string&
61596
61597   return jresult;
61598 }
61599
61600
61601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61602   void * jresult ;
61603   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61604   std::string *arg2 = 0 ;
61605   Dali::Property::Map *arg3 = 0 ;
61606   Dali::Animation result;
61607
61608   arg1 = (Dali::Toolkit::Builder *)jarg1;
61609   if (!jarg2) {
61610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61611     return 0;
61612   }
61613   std::string arg2_str(jarg2);
61614   arg2 = &arg2_str;
61615   arg3 = (Dali::Property::Map *)jarg3;
61616   if (!arg3) {
61617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61618     return 0;
61619   }
61620   {
61621     try {
61622       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61623     } catch (std::out_of_range& e) {
61624       {
61625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61626       };
61627     } catch (std::exception& e) {
61628       {
61629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61630       };
61631     } catch (Dali::DaliException e) {
61632       {
61633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61634       };
61635     } catch (...) {
61636       {
61637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61638       };
61639     }
61640   }
61641
61642   jresult = new Dali::Animation((const Dali::Animation &)result);
61643
61644   //argout typemap for const std::string&
61645
61646   return jresult;
61647 }
61648
61649
61650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
61651   void * jresult ;
61652   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61653   std::string *arg2 = 0 ;
61654   Dali::Actor arg3 ;
61655   Dali::Actor *argp3 ;
61656   Dali::Animation result;
61657
61658   arg1 = (Dali::Toolkit::Builder *)jarg1;
61659   if (!jarg2) {
61660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61661     return 0;
61662   }
61663   std::string arg2_str(jarg2);
61664   arg2 = &arg2_str;
61665   argp3 = (Dali::Actor *)jarg3;
61666   if (!argp3) {
61667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61668     return 0;
61669   }
61670   arg3 = *argp3;
61671   {
61672     try {
61673       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
61674     } catch (std::out_of_range& e) {
61675       {
61676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61677       };
61678     } catch (std::exception& e) {
61679       {
61680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61681       };
61682     } catch (Dali::DaliException e) {
61683       {
61684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61685       };
61686     } catch (...) {
61687       {
61688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61689       };
61690     }
61691   }
61692
61693   jresult = new Dali::Animation((const Dali::Animation &)result);
61694
61695   //argout typemap for const std::string&
61696
61697   return jresult;
61698 }
61699
61700
61701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
61702   void * jresult ;
61703   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61704   std::string *arg2 = 0 ;
61705   Dali::Property::Map *arg3 = 0 ;
61706   Dali::Actor arg4 ;
61707   Dali::Actor *argp4 ;
61708   Dali::Animation result;
61709
61710   arg1 = (Dali::Toolkit::Builder *)jarg1;
61711   if (!jarg2) {
61712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61713     return 0;
61714   }
61715   std::string arg2_str(jarg2);
61716   arg2 = &arg2_str;
61717   arg3 = (Dali::Property::Map *)jarg3;
61718   if (!arg3) {
61719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61720     return 0;
61721   }
61722   argp4 = (Dali::Actor *)jarg4;
61723   if (!argp4) {
61724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61725     return 0;
61726   }
61727   arg4 = *argp4;
61728   {
61729     try {
61730       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
61731     } catch (std::out_of_range& e) {
61732       {
61733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61734       };
61735     } catch (std::exception& e) {
61736       {
61737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61738       };
61739     } catch (Dali::DaliException e) {
61740       {
61741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61742       };
61743     } catch (...) {
61744       {
61745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61746       };
61747     }
61748   }
61749
61750   jresult = new Dali::Animation((const Dali::Animation &)result);
61751
61752   //argout typemap for const std::string&
61753
61754   return jresult;
61755 }
61756
61757
61758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
61759   void * jresult ;
61760   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61761   std::string *arg2 = 0 ;
61762   Dali::BaseHandle result;
61763
61764   arg1 = (Dali::Toolkit::Builder *)jarg1;
61765   if (!jarg2) {
61766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61767     return 0;
61768   }
61769   std::string arg2_str(jarg2);
61770   arg2 = &arg2_str;
61771   {
61772     try {
61773       result = (arg1)->Create((std::string const &)*arg2);
61774     } catch (std::out_of_range& e) {
61775       {
61776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61777       };
61778     } catch (std::exception& e) {
61779       {
61780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61781       };
61782     } catch (Dali::DaliException e) {
61783       {
61784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61785       };
61786     } catch (...) {
61787       {
61788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61789       };
61790     }
61791   }
61792
61793   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61794
61795   //argout typemap for const std::string&
61796
61797   return jresult;
61798 }
61799
61800
61801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61802   void * jresult ;
61803   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61804   std::string *arg2 = 0 ;
61805   Dali::Property::Map *arg3 = 0 ;
61806   Dali::BaseHandle result;
61807
61808   arg1 = (Dali::Toolkit::Builder *)jarg1;
61809   if (!jarg2) {
61810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61811     return 0;
61812   }
61813   std::string arg2_str(jarg2);
61814   arg2 = &arg2_str;
61815   arg3 = (Dali::Property::Map *)jarg3;
61816   if (!arg3) {
61817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61818     return 0;
61819   }
61820   {
61821     try {
61822       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61823     } catch (std::out_of_range& e) {
61824       {
61825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61826       };
61827     } catch (std::exception& e) {
61828       {
61829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61830       };
61831     } catch (Dali::DaliException e) {
61832       {
61833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61834       };
61835     } catch (...) {
61836       {
61837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61838       };
61839     }
61840   }
61841
61842   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61843
61844   //argout typemap for const std::string&
61845
61846   return jresult;
61847 }
61848
61849
61850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
61851   void * jresult ;
61852   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61853   std::string *arg2 = 0 ;
61854   Dali::BaseHandle result;
61855
61856   arg1 = (Dali::Toolkit::Builder *)jarg1;
61857   if (!jarg2) {
61858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61859     return 0;
61860   }
61861   std::string arg2_str(jarg2);
61862   arg2 = &arg2_str;
61863   {
61864     try {
61865       result = (arg1)->CreateFromJson((std::string const &)*arg2);
61866     } catch (std::out_of_range& e) {
61867       {
61868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61869       };
61870     } catch (std::exception& e) {
61871       {
61872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61873       };
61874     } catch (Dali::DaliException e) {
61875       {
61876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61877       };
61878     } catch (...) {
61879       {
61880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61881       };
61882     }
61883   }
61884
61885   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61886
61887   //argout typemap for const std::string&
61888
61889   return jresult;
61890 }
61891
61892
61893 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
61894   unsigned int jresult ;
61895   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61896   std::string *arg2 = 0 ;
61897   Dali::Handle *arg3 = 0 ;
61898   bool result;
61899
61900   arg1 = (Dali::Toolkit::Builder *)jarg1;
61901   if (!jarg2) {
61902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61903     return 0;
61904   }
61905   std::string arg2_str(jarg2);
61906   arg2 = &arg2_str;
61907   arg3 = (Dali::Handle *)jarg3;
61908   if (!arg3) {
61909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
61910     return 0;
61911   }
61912   {
61913     try {
61914       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
61915     } catch (std::out_of_range& e) {
61916       {
61917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61918       };
61919     } catch (std::exception& e) {
61920       {
61921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61922       };
61923     } catch (Dali::DaliException e) {
61924       {
61925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61926       };
61927     } catch (...) {
61928       {
61929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61930       };
61931     }
61932   }
61933
61934   jresult = result;
61935
61936   //argout typemap for const std::string&
61937
61938   return jresult;
61939 }
61940
61941
61942 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
61943   unsigned int jresult ;
61944   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61945   Dali::Handle *arg2 = 0 ;
61946   std::string *arg3 = 0 ;
61947   bool result;
61948
61949   arg1 = (Dali::Toolkit::Builder *)jarg1;
61950   arg2 = (Dali::Handle *)jarg2;
61951   if (!arg2) {
61952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
61953     return 0;
61954   }
61955   if (!jarg3) {
61956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61957     return 0;
61958   }
61959   std::string arg3_str(jarg3);
61960   arg3 = &arg3_str;
61961   {
61962     try {
61963       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
61964     } catch (std::out_of_range& e) {
61965       {
61966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61967       };
61968     } catch (std::exception& e) {
61969       {
61970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61971       };
61972     } catch (Dali::DaliException e) {
61973       {
61974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61975       };
61976     } catch (...) {
61977       {
61978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61979       };
61980     }
61981   }
61982
61983   jresult = result;
61984
61985   //argout typemap for const std::string&
61986
61987   return jresult;
61988 }
61989
61990
61991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
61992   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61993   Dali::Actor arg2 ;
61994   Dali::Actor *argp2 ;
61995
61996   arg1 = (Dali::Toolkit::Builder *)jarg1;
61997   argp2 = (Dali::Actor *)jarg2;
61998   if (!argp2) {
61999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62000     return ;
62001   }
62002   arg2 = *argp2;
62003   {
62004     try {
62005       (arg1)->AddActors(arg2);
62006     } catch (std::out_of_range& e) {
62007       {
62008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62009       };
62010     } catch (std::exception& e) {
62011       {
62012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62013       };
62014     } catch (Dali::DaliException e) {
62015       {
62016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62017       };
62018     } catch (...) {
62019       {
62020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62021       };
62022     }
62023   }
62024
62025 }
62026
62027
62028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
62029   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62030   std::string *arg2 = 0 ;
62031   Dali::Actor arg3 ;
62032   Dali::Actor *argp3 ;
62033
62034   arg1 = (Dali::Toolkit::Builder *)jarg1;
62035   if (!jarg2) {
62036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62037     return ;
62038   }
62039   std::string arg2_str(jarg2);
62040   arg2 = &arg2_str;
62041   argp3 = (Dali::Actor *)jarg3;
62042   if (!argp3) {
62043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62044     return ;
62045   }
62046   arg3 = *argp3;
62047   {
62048     try {
62049       (arg1)->AddActors((std::string const &)*arg2,arg3);
62050     } catch (std::out_of_range& e) {
62051       {
62052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62053       };
62054     } catch (std::exception& e) {
62055       {
62056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62057       };
62058     } catch (Dali::DaliException e) {
62059       {
62060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62061       };
62062     } catch (...) {
62063       {
62064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62065       };
62066     }
62067   }
62068
62069
62070   //argout typemap for const std::string&
62071
62072 }
62073
62074
62075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
62076   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62077   std::string *arg2 = 0 ;
62078
62079   arg1 = (Dali::Toolkit::Builder *)jarg1;
62080   if (!jarg2) {
62081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62082     return ;
62083   }
62084   std::string arg2_str(jarg2);
62085   arg2 = &arg2_str;
62086   {
62087     try {
62088       (arg1)->CreateRenderTask((std::string const &)*arg2);
62089     } catch (std::out_of_range& e) {
62090       {
62091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62092       };
62093     } catch (std::exception& e) {
62094       {
62095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62096       };
62097     } catch (Dali::DaliException e) {
62098       {
62099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62100       };
62101     } catch (...) {
62102       {
62103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62104       };
62105     }
62106   }
62107
62108
62109   //argout typemap for const std::string&
62110
62111 }
62112
62113
62114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
62115   void * jresult ;
62116   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62117   std::string *arg2 = 0 ;
62118   Dali::Path result;
62119
62120   arg1 = (Dali::Toolkit::Builder *)jarg1;
62121   if (!jarg2) {
62122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62123     return 0;
62124   }
62125   std::string arg2_str(jarg2);
62126   arg2 = &arg2_str;
62127   {
62128     try {
62129       result = (arg1)->GetPath((std::string const &)*arg2);
62130     } catch (std::out_of_range& e) {
62131       {
62132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62133       };
62134     } catch (std::exception& e) {
62135       {
62136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62137       };
62138     } catch (Dali::DaliException e) {
62139       {
62140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62141       };
62142     } catch (...) {
62143       {
62144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62145       };
62146     }
62147   }
62148
62149   jresult = new Dali::Path((const Dali::Path &)result);
62150
62151   //argout typemap for const std::string&
62152
62153   return jresult;
62154 }
62155
62156
62157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
62158   void * jresult ;
62159   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62160   std::string *arg2 = 0 ;
62161   Dali::PathConstrainer result;
62162
62163   arg1 = (Dali::Toolkit::Builder *)jarg1;
62164   if (!jarg2) {
62165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62166     return 0;
62167   }
62168   std::string arg2_str(jarg2);
62169   arg2 = &arg2_str;
62170   {
62171     try {
62172       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
62173     } catch (std::out_of_range& e) {
62174       {
62175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62176       };
62177     } catch (std::exception& e) {
62178       {
62179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62180       };
62181     } catch (Dali::DaliException e) {
62182       {
62183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62184       };
62185     } catch (...) {
62186       {
62187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62188       };
62189     }
62190   }
62191
62192   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
62193
62194   //argout typemap for const std::string&
62195
62196   return jresult;
62197 }
62198
62199
62200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
62201   void * jresult ;
62202   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62203   std::string *arg2 = 0 ;
62204   Dali::LinearConstrainer result;
62205
62206   arg1 = (Dali::Toolkit::Builder *)jarg1;
62207   if (!jarg2) {
62208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62209     return 0;
62210   }
62211   std::string arg2_str(jarg2);
62212   arg2 = &arg2_str;
62213   {
62214     try {
62215       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
62216     } catch (std::out_of_range& e) {
62217       {
62218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62219       };
62220     } catch (std::exception& e) {
62221       {
62222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62223       };
62224     } catch (Dali::DaliException e) {
62225       {
62226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62227       };
62228     } catch (...) {
62229       {
62230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62231       };
62232     }
62233   }
62234
62235   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
62236
62237   //argout typemap for const std::string&
62238
62239   return jresult;
62240 }
62241
62242
62243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
62244   void * jresult ;
62245   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62246   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
62247
62248   arg1 = (Dali::Toolkit::Builder *)jarg1;
62249   {
62250     try {
62251       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
62252     } catch (std::out_of_range& e) {
62253       {
62254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62255       };
62256     } catch (std::exception& e) {
62257       {
62258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62259       };
62260     } catch (Dali::DaliException e) {
62261       {
62262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62263       };
62264     } catch (...) {
62265       {
62266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62267       };
62268     }
62269   }
62270
62271   jresult = (void *)result;
62272   return jresult;
62273 }
62274
62275
62276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
62277   void * jresult ;
62278   Dali::Toolkit::TransitionData *result = 0 ;
62279
62280   {
62281     try {
62282       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
62283     } catch (std::out_of_range& e) {
62284       {
62285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62286       };
62287     } catch (std::exception& e) {
62288       {
62289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62290       };
62291     } catch (Dali::DaliException e) {
62292       {
62293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62294       };
62295     } catch (...) {
62296       {
62297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62298       };
62299     }
62300   }
62301
62302   jresult = (void *)result;
62303   return jresult;
62304 }
62305
62306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
62307   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62308
62309   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62310   {
62311     try {
62312       delete arg1;
62313     } catch (std::out_of_range& e) {
62314       {
62315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62316       };
62317     } catch (std::exception& e) {
62318       {
62319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62320       };
62321     } catch (Dali::DaliException e) {
62322       {
62323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62324       };
62325     } catch (...) {
62326       {
62327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62328       };
62329     }
62330   }
62331
62332 }
62333
62334
62335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
62336   void * jresult ;
62337   Dali::Property::Map *arg1 = 0 ;
62338   Dali::Toolkit::TransitionData result;
62339
62340   arg1 = (Dali::Property::Map *)jarg1;
62341   if (!arg1) {
62342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62343     return 0;
62344   }
62345   {
62346     try {
62347       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
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::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62368   return jresult;
62369 }
62370
62371
62372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
62373   void * jresult ;
62374   Dali::Property::Array *arg1 = 0 ;
62375   Dali::Toolkit::TransitionData result;
62376
62377   arg1 = (Dali::Property::Array *)jarg1;
62378   if (!arg1) {
62379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
62380     return 0;
62381   }
62382   {
62383     try {
62384       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
62385     } catch (std::out_of_range& e) {
62386       {
62387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62388       };
62389     } catch (std::exception& e) {
62390       {
62391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62392       };
62393     } catch (Dali::DaliException e) {
62394       {
62395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62396       };
62397     } catch (...) {
62398       {
62399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62400       };
62401     }
62402   }
62403
62404   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62405   return jresult;
62406 }
62407
62408
62409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
62410   void * jresult ;
62411   Dali::BaseHandle arg1 ;
62412   Dali::BaseHandle *argp1 ;
62413   Dali::Toolkit::TransitionData result;
62414
62415   argp1 = (Dali::BaseHandle *)jarg1;
62416   if (!argp1) {
62417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62418     return 0;
62419   }
62420   arg1 = *argp1;
62421   {
62422     try {
62423       result = Dali::Toolkit::TransitionData::DownCast(arg1);
62424     } catch (std::out_of_range& e) {
62425       {
62426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62427       };
62428     } catch (std::exception& e) {
62429       {
62430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62431       };
62432     } catch (Dali::DaliException e) {
62433       {
62434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62435       };
62436     } catch (...) {
62437       {
62438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62439       };
62440     }
62441   }
62442
62443   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62444   return jresult;
62445 }
62446
62447
62448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
62449   void * jresult ;
62450   Dali::Toolkit::TransitionData *arg1 = 0 ;
62451   Dali::Toolkit::TransitionData *result = 0 ;
62452
62453   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62454   if (!arg1) {
62455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62456     return 0;
62457   }
62458   {
62459     try {
62460       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
62461     } catch (std::out_of_range& e) {
62462       {
62463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62464       };
62465     } catch (std::exception& e) {
62466       {
62467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62468       };
62469     } catch (Dali::DaliException e) {
62470       {
62471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62472       };
62473     } catch (...) {
62474       {
62475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62476       };
62477     }
62478   }
62479
62480   jresult = (void *)result;
62481   return jresult;
62482 }
62483
62484
62485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
62486   void * jresult ;
62487   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62488   Dali::Toolkit::TransitionData *arg2 = 0 ;
62489   Dali::Toolkit::TransitionData *result = 0 ;
62490
62491   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62492   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
62493   if (!arg2) {
62494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62495     return 0;
62496   }
62497   {
62498     try {
62499       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
62500     } catch (std::out_of_range& e) {
62501       {
62502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62503       };
62504     } catch (std::exception& e) {
62505       {
62506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62507       };
62508     } catch (Dali::DaliException e) {
62509       {
62510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62511       };
62512     } catch (...) {
62513       {
62514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62515       };
62516     }
62517   }
62518
62519   jresult = (void *)result;
62520   return jresult;
62521 }
62522
62523
62524 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
62525   unsigned long jresult ;
62526   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62527   size_t result;
62528
62529   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62530   {
62531     try {
62532       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
62533     } catch (std::out_of_range& e) {
62534       {
62535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62536       };
62537     } catch (std::exception& e) {
62538       {
62539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62540       };
62541     } catch (Dali::DaliException e) {
62542       {
62543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62544       };
62545     } catch (...) {
62546       {
62547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62548       };
62549     }
62550   }
62551
62552   jresult = (unsigned long)result;
62553   return jresult;
62554 }
62555
62556
62557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
62558   void * jresult ;
62559   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62560   size_t arg2 ;
62561   Dali::Property::Map result;
62562
62563   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62564   arg2 = (size_t)jarg2;
62565   {
62566     try {
62567       result = (arg1)->GetAnimatorAt(arg2);
62568     } catch (std::out_of_range& e) {
62569       {
62570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62571       };
62572     } catch (std::exception& e) {
62573       {
62574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62575       };
62576     } catch (Dali::DaliException e) {
62577       {
62578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62579       };
62580     } catch (...) {
62581       {
62582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62583       };
62584     }
62585   }
62586
62587   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
62588   return jresult;
62589 }
62590
62591
62592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
62593   int jresult ;
62594   int result;
62595
62596   {
62597     try {
62598       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
62599     } catch (std::out_of_range& e) {
62600       {
62601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62602       };
62603     } catch (std::exception& e) {
62604       {
62605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62606       };
62607     } catch (Dali::DaliException e) {
62608       {
62609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62610       };
62611     } catch (...) {
62612       {
62613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62614       };
62615     }
62616   }
62617
62618   jresult = (int)result;
62619   return jresult;
62620 }
62621
62622
62623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
62624   int jresult ;
62625   int result;
62626
62627   {
62628     try {
62629       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
62630     } catch (std::out_of_range& e) {
62631       {
62632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62633       };
62634     } catch (std::exception& e) {
62635       {
62636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62637       };
62638     } catch (Dali::DaliException e) {
62639       {
62640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62641       };
62642     } catch (...) {
62643       {
62644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62645       };
62646     }
62647   }
62648
62649   jresult = (int)result;
62650   return jresult;
62651 }
62652
62653
62654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
62655   int jresult ;
62656   int result;
62657
62658   {
62659     try {
62660       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
62661     } catch (std::out_of_range& e) {
62662       {
62663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62664       };
62665     } catch (std::exception& e) {
62666       {
62667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62668       };
62669     } catch (Dali::DaliException e) {
62670       {
62671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62672       };
62673     } catch (...) {
62674       {
62675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62676       };
62677     }
62678   }
62679
62680   jresult = (int)result;
62681   return jresult;
62682 }
62683
62684
62685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
62686   int jresult ;
62687   int result;
62688
62689   {
62690     try {
62691       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
62692     } catch (std::out_of_range& e) {
62693       {
62694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62695       };
62696     } catch (std::exception& e) {
62697       {
62698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62699       };
62700     } catch (Dali::DaliException e) {
62701       {
62702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62703       };
62704     } catch (...) {
62705       {
62706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62707       };
62708     }
62709   }
62710
62711   jresult = (int)result;
62712   return jresult;
62713 }
62714
62715
62716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
62717   int jresult ;
62718   int result;
62719
62720   {
62721     try {
62722       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
62723     } catch (std::out_of_range& e) {
62724       {
62725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62726       };
62727     } catch (std::exception& e) {
62728       {
62729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62730       };
62731     } catch (Dali::DaliException e) {
62732       {
62733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62734       };
62735     } catch (...) {
62736       {
62737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62738       };
62739     }
62740   }
62741
62742   jresult = (int)result;
62743   return jresult;
62744 }
62745
62746
62747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
62748   int jresult ;
62749   int result;
62750
62751   {
62752     try {
62753       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
62754     } catch (std::out_of_range& e) {
62755       {
62756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62757       };
62758     } catch (std::exception& e) {
62759       {
62760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62761       };
62762     } catch (Dali::DaliException e) {
62763       {
62764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62765       };
62766     } catch (...) {
62767       {
62768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62769       };
62770     }
62771   }
62772
62773   jresult = (int)result;
62774   return jresult;
62775 }
62776
62777
62778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
62779   int jresult ;
62780   int result;
62781
62782   {
62783     try {
62784       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
62785     } catch (std::out_of_range& e) {
62786       {
62787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62788       };
62789     } catch (std::exception& e) {
62790       {
62791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62792       };
62793     } catch (Dali::DaliException e) {
62794       {
62795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62796       };
62797     } catch (...) {
62798       {
62799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62800       };
62801     }
62802   }
62803
62804   jresult = (int)result;
62805   return jresult;
62806 }
62807
62808
62809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
62810   int jresult ;
62811   int result;
62812
62813   {
62814     try {
62815       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
62816     } catch (std::out_of_range& e) {
62817       {
62818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62819       };
62820     } catch (std::exception& e) {
62821       {
62822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62823       };
62824     } catch (Dali::DaliException e) {
62825       {
62826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62827       };
62828     } catch (...) {
62829       {
62830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62831       };
62832     }
62833   }
62834
62835   jresult = (int)result;
62836   return jresult;
62837 }
62838
62839
62840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
62841   int jresult ;
62842   int result;
62843
62844   {
62845     try {
62846       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
62847     } catch (std::out_of_range& e) {
62848       {
62849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62850       };
62851     } catch (std::exception& e) {
62852       {
62853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62854       };
62855     } catch (Dali::DaliException e) {
62856       {
62857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62858       };
62859     } catch (...) {
62860       {
62861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62862       };
62863     }
62864   }
62865
62866   jresult = (int)result;
62867   return jresult;
62868 }
62869
62870
62871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
62872   int jresult ;
62873   int result;
62874
62875   {
62876     try {
62877       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
62878     } catch (std::out_of_range& e) {
62879       {
62880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62881       };
62882     } catch (std::exception& e) {
62883       {
62884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62885       };
62886     } catch (Dali::DaliException e) {
62887       {
62888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62889       };
62890     } catch (...) {
62891       {
62892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62893       };
62894     }
62895   }
62896
62897   jresult = (int)result;
62898   return jresult;
62899 }
62900
62901
62902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
62903   int jresult ;
62904   int result;
62905
62906   {
62907     try {
62908       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
62909     } catch (std::out_of_range& e) {
62910       {
62911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62912       };
62913     } catch (std::exception& e) {
62914       {
62915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62916       };
62917     } catch (Dali::DaliException e) {
62918       {
62919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62920       };
62921     } catch (...) {
62922       {
62923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62924       };
62925     }
62926   }
62927
62928   jresult = (int)result;
62929   return jresult;
62930 }
62931
62932
62933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
62934   int jresult ;
62935   int result;
62936
62937   {
62938     try {
62939       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
62940     } catch (std::out_of_range& e) {
62941       {
62942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62943       };
62944     } catch (std::exception& e) {
62945       {
62946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62947       };
62948     } catch (Dali::DaliException e) {
62949       {
62950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62951       };
62952     } catch (...) {
62953       {
62954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62955       };
62956     }
62957   }
62958
62959   jresult = (int)result;
62960   return jresult;
62961 }
62962
62963
62964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
62965   int jresult ;
62966   int result;
62967
62968   {
62969     try {
62970       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
62971     } catch (std::out_of_range& e) {
62972       {
62973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62974       };
62975     } catch (std::exception& e) {
62976       {
62977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62978       };
62979     } catch (Dali::DaliException e) {
62980       {
62981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62982       };
62983     } catch (...) {
62984       {
62985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62986       };
62987     }
62988   }
62989
62990   jresult = (int)result;
62991   return jresult;
62992 }
62993
62994
62995 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
62996   int jresult ;
62997   int result;
62998
62999   {
63000     try {
63001       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
63002     } catch (std::out_of_range& e) {
63003       {
63004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63005       };
63006     } catch (std::exception& e) {
63007       {
63008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63009       };
63010     } catch (Dali::DaliException e) {
63011       {
63012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63013       };
63014     } catch (...) {
63015       {
63016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63017       };
63018     }
63019   }
63020
63021   jresult = (int)result;
63022   return jresult;
63023 }
63024
63025
63026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
63027   void * jresult ;
63028   Dali::Toolkit::Control result;
63029
63030   {
63031     try {
63032       result = Dali::Toolkit::Internal::Control::New();
63033     } catch (std::out_of_range& e) {
63034       {
63035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63036       };
63037     } catch (std::exception& e) {
63038       {
63039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63040       };
63041     } catch (Dali::DaliException e) {
63042       {
63043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63044       };
63045     } catch (...) {
63046       {
63047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63048       };
63049     }
63050   }
63051
63052   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63053   return jresult;
63054 }
63055
63056
63057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
63058   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63059   std::string *arg2 = 0 ;
63060
63061   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63062   if (!jarg2) {
63063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63064     return ;
63065   }
63066   std::string arg2_str(jarg2);
63067   arg2 = &arg2_str;
63068   {
63069     try {
63070       (arg1)->SetStyleName((std::string const &)*arg2);
63071     } catch (std::out_of_range& e) {
63072       {
63073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63074       };
63075     } catch (std::exception& e) {
63076       {
63077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63078       };
63079     } catch (Dali::DaliException e) {
63080       {
63081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63082       };
63083     } catch (...) {
63084       {
63085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63086       };
63087     }
63088   }
63089
63090
63091   //argout typemap for const std::string&
63092
63093 }
63094
63095
63096 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
63097   char * jresult ;
63098   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63099   std::string *result = 0 ;
63100
63101   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63102   {
63103     try {
63104       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
63105     } catch (std::out_of_range& e) {
63106       {
63107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63108       };
63109     } catch (std::exception& e) {
63110       {
63111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63112       };
63113     } catch (Dali::DaliException e) {
63114       {
63115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63116       };
63117     } catch (...) {
63118       {
63119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63120       };
63121     }
63122   }
63123
63124   jresult = SWIG_csharp_string_callback(result->c_str());
63125   return jresult;
63126 }
63127
63128
63129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
63130   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63131   Dali::Vector4 *arg2 = 0 ;
63132
63133   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63134   arg2 = (Dali::Vector4 *)jarg2;
63135   if (!arg2) {
63136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63137     return ;
63138   }
63139   {
63140     try {
63141       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63142     } catch (std::out_of_range& e) {
63143       {
63144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63145       };
63146     } catch (std::exception& e) {
63147       {
63148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63149       };
63150     } catch (Dali::DaliException e) {
63151       {
63152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63153       };
63154     } catch (...) {
63155       {
63156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63157       };
63158     }
63159   }
63160
63161 }
63162
63163
63164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
63165   void * jresult ;
63166   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
63167   Dali::Vector4 result;
63168
63169   arg1 = (Dali::Handle *)jarg1;
63170   {
63171     try {
63172       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
63173       if (resultMap)
63174       {
63175         Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE );
63176         if(type && type->Get<int>() == Visual::COLOR )
63177         {
63178           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
63179           if (value)
63180           {
63181             result = value->Get<Vector4>();
63182           }
63183         }
63184       }
63185     } catch (std::out_of_range& e) {
63186       {
63187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63188       };
63189     } catch (std::exception& e) {
63190       {
63191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63192       };
63193     } catch (Dali::DaliException e) {
63194       {
63195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63196       };
63197     } catch (...) {
63198       {
63199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63200       };
63201     }
63202   }
63203
63204   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63205   return jresult;
63206 }
63207
63208
63209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
63210   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63211   Dali::Property::Map *arg2 = 0 ;
63212
63213   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63214   arg2 = (Dali::Property::Map *)jarg2;
63215   if (!arg2) {
63216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
63217     return ;
63218   }
63219   {
63220     try {
63221       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
63222     } catch (std::out_of_range& e) {
63223       {
63224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63225       };
63226     } catch (std::exception& e) {
63227       {
63228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63229       };
63230     } catch (Dali::DaliException e) {
63231       {
63232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63233       };
63234     } catch (...) {
63235       {
63236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63237       };
63238     }
63239   }
63240
63241 }
63242
63243
63244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
63245   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63246
63247   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63248   {
63249     try {
63250       (arg1)->ClearBackground();
63251     } catch (std::out_of_range& e) {
63252       {
63253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63254       };
63255     } catch (std::exception& e) {
63256       {
63257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63258       };
63259     } catch (Dali::DaliException e) {
63260       {
63261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63262       };
63263     } catch (...) {
63264       {
63265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63266       };
63267     }
63268   }
63269
63270 }
63271
63272
63273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
63274   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63275   Dali::Gesture::Type arg2 ;
63276
63277   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63278   arg2 = (Dali::Gesture::Type)jarg2;
63279   {
63280     try {
63281       (arg1)->EnableGestureDetection(arg2);
63282     } catch (std::out_of_range& e) {
63283       {
63284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63285       };
63286     } catch (std::exception& e) {
63287       {
63288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63289       };
63290     } catch (Dali::DaliException e) {
63291       {
63292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63293       };
63294     } catch (...) {
63295       {
63296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63297       };
63298     }
63299   }
63300
63301 }
63302
63303
63304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
63305   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63306   Dali::Gesture::Type arg2 ;
63307
63308   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63309   arg2 = (Dali::Gesture::Type)jarg2;
63310   {
63311     try {
63312       (arg1)->DisableGestureDetection(arg2);
63313     } catch (std::out_of_range& e) {
63314       {
63315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63316       };
63317     } catch (std::exception& e) {
63318       {
63319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63320       };
63321     } catch (Dali::DaliException e) {
63322       {
63323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63324       };
63325     } catch (...) {
63326       {
63327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63328       };
63329     }
63330   }
63331
63332 }
63333
63334
63335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
63336   void * jresult ;
63337   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63338   Dali::PinchGestureDetector result;
63339
63340   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63341   {
63342     try {
63343       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
63344     } catch (std::out_of_range& e) {
63345       {
63346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63347       };
63348     } catch (std::exception& e) {
63349       {
63350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63351       };
63352     } catch (Dali::DaliException e) {
63353       {
63354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63355       };
63356     } catch (...) {
63357       {
63358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63359       };
63360     }
63361   }
63362
63363   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63364   return jresult;
63365 }
63366
63367
63368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
63369   void * jresult ;
63370   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63371   Dali::PanGestureDetector result;
63372
63373   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63374   {
63375     try {
63376       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
63377     } catch (std::out_of_range& e) {
63378       {
63379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63380       };
63381     } catch (std::exception& e) {
63382       {
63383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63384       };
63385     } catch (Dali::DaliException e) {
63386       {
63387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63388       };
63389     } catch (...) {
63390       {
63391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63392       };
63393     }
63394   }
63395
63396   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63397   return jresult;
63398 }
63399
63400
63401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
63402   void * jresult ;
63403   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63404   Dali::TapGestureDetector result;
63405
63406   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63407   {
63408     try {
63409       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
63410     } catch (std::out_of_range& e) {
63411       {
63412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63413       };
63414     } catch (std::exception& e) {
63415       {
63416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63417       };
63418     } catch (Dali::DaliException e) {
63419       {
63420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63421       };
63422     } catch (...) {
63423       {
63424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63425       };
63426     }
63427   }
63428
63429   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63430   return jresult;
63431 }
63432
63433
63434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
63435   void * jresult ;
63436   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63437   Dali::LongPressGestureDetector result;
63438
63439   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63440   {
63441     try {
63442       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
63443     } catch (std::out_of_range& e) {
63444       {
63445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63446       };
63447     } catch (std::exception& e) {
63448       {
63449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63450       };
63451     } catch (Dali::DaliException e) {
63452       {
63453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63454       };
63455     } catch (...) {
63456       {
63457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63458       };
63459     }
63460   }
63461
63462   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63463   return jresult;
63464 }
63465
63466
63467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
63468   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63469   bool arg2 ;
63470
63471   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63472   arg2 = jarg2 ? true : false;
63473   {
63474     try {
63475       (arg1)->SetKeyboardNavigationSupport(arg2);
63476     } catch (std::out_of_range& e) {
63477       {
63478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63479       };
63480     } catch (std::exception& e) {
63481       {
63482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63483       };
63484     } catch (Dali::DaliException e) {
63485       {
63486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63487       };
63488     } catch (...) {
63489       {
63490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63491       };
63492     }
63493   }
63494
63495 }
63496
63497
63498 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
63499   unsigned int jresult ;
63500   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63501   bool result;
63502
63503   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63504   {
63505     try {
63506       result = (bool)(arg1)->IsKeyboardNavigationSupported();
63507     } catch (std::out_of_range& e) {
63508       {
63509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63510       };
63511     } catch (std::exception& e) {
63512       {
63513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63514       };
63515     } catch (Dali::DaliException e) {
63516       {
63517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63518       };
63519     } catch (...) {
63520       {
63521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63522       };
63523     }
63524   }
63525
63526   jresult = result;
63527   return jresult;
63528 }
63529
63530
63531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
63532   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63533
63534   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63535   {
63536     try {
63537       (arg1)->SetKeyInputFocus();
63538     } catch (std::out_of_range& e) {
63539       {
63540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63541       };
63542     } catch (std::exception& e) {
63543       {
63544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63545       };
63546     } catch (Dali::DaliException e) {
63547       {
63548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63549       };
63550     } catch (...) {
63551       {
63552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63553       };
63554     }
63555   }
63556
63557 }
63558
63559
63560 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
63561   unsigned int jresult ;
63562   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63563   bool result;
63564
63565   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63566   {
63567     try {
63568       result = (bool)(arg1)->HasKeyInputFocus();
63569     } catch (std::out_of_range& e) {
63570       {
63571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63572       };
63573     } catch (std::exception& e) {
63574       {
63575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63576       };
63577     } catch (Dali::DaliException e) {
63578       {
63579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63580       };
63581     } catch (...) {
63582       {
63583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63584       };
63585     }
63586   }
63587
63588   jresult = result;
63589   return jresult;
63590 }
63591
63592
63593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
63594   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63595
63596   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63597   {
63598     try {
63599       (arg1)->ClearKeyInputFocus();
63600     } catch (std::out_of_range& e) {
63601       {
63602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63603       };
63604     } catch (std::exception& e) {
63605       {
63606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63607       };
63608     } catch (Dali::DaliException e) {
63609       {
63610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63611       };
63612     } catch (...) {
63613       {
63614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63615       };
63616     }
63617   }
63618
63619 }
63620
63621
63622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
63623   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63624   bool arg2 ;
63625
63626   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63627   arg2 = jarg2 ? true : false;
63628   {
63629     try {
63630       (arg1)->SetAsKeyboardFocusGroup(arg2);
63631     } catch (std::out_of_range& e) {
63632       {
63633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63634       };
63635     } catch (std::exception& e) {
63636       {
63637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63638       };
63639     } catch (Dali::DaliException e) {
63640       {
63641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63642       };
63643     } catch (...) {
63644       {
63645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63646       };
63647     }
63648   }
63649
63650 }
63651
63652
63653 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
63654   unsigned int jresult ;
63655   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63656   bool result;
63657
63658   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63659   {
63660     try {
63661       result = (bool)(arg1)->IsKeyboardFocusGroup();
63662     } catch (std::out_of_range& e) {
63663       {
63664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63665       };
63666     } catch (std::exception& e) {
63667       {
63668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63669       };
63670     } catch (Dali::DaliException e) {
63671       {
63672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63673       };
63674     } catch (...) {
63675       {
63676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63677       };
63678     }
63679   }
63680
63681   jresult = result;
63682   return jresult;
63683 }
63684
63685
63686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
63687   void * jresult ;
63688   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63689   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63690
63691   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63692   {
63693     try {
63694       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63695     } catch (std::out_of_range& e) {
63696       {
63697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63698       };
63699     } catch (std::exception& e) {
63700       {
63701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63702       };
63703     } catch (Dali::DaliException e) {
63704       {
63705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63706       };
63707     } catch (...) {
63708       {
63709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63710       };
63711     }
63712   }
63713
63714   jresult = (void *)result;
63715   return jresult;
63716 }
63717
63718
63719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
63720   void * jresult ;
63721   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63722   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63723
63724   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63725   {
63726     try {
63727       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63728     } catch (std::out_of_range& e) {
63729       {
63730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63731       };
63732     } catch (std::exception& e) {
63733       {
63734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63735       };
63736     } catch (Dali::DaliException e) {
63737       {
63738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63739       };
63740     } catch (...) {
63741       {
63742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63743       };
63744     }
63745   }
63746
63747   jresult = (void *)result;
63748   return jresult;
63749 }
63750
63751
63752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
63753   void * jresult ;
63754   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63755   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63756
63757   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63758   {
63759     try {
63760       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63761     } catch (std::out_of_range& e) {
63762       {
63763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63764       };
63765     } catch (std::exception& e) {
63766       {
63767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63768       };
63769     } catch (Dali::DaliException e) {
63770       {
63771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63772       };
63773     } catch (...) {
63774       {
63775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63776       };
63777     }
63778   }
63779
63780   jresult = (void *)result;
63781   return jresult;
63782 }
63783
63784
63785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
63786   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63787   int arg2 ;
63788   SwigDirector_ViewImpl *darg = 0;
63789
63790   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63791   arg2 = (int)jarg2;
63792   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63793   if(!darg) {
63794     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63795     return;
63796   }
63797   {
63798     try {
63799       if(darg) {
63800         (darg)->OnStageConnection(arg2);
63801       }
63802     } catch (std::out_of_range& e) {
63803       {
63804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63805       };
63806     } catch (std::exception& e) {
63807       {
63808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63809       };
63810     } catch (Dali::DaliException e) {
63811       {
63812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63813       };
63814     } catch (...) {
63815       {
63816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63817       };
63818     }
63819   }
63820
63821 }
63822
63823
63824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
63825   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63826   int arg2 ;
63827   SwigDirector_ViewImpl *darg = 0;
63828
63829   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63830   arg2 = (int)jarg2;
63831   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63832   if(!darg) {
63833     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63834     return;
63835   }
63836   {
63837     try {
63838       if(darg) {
63839         (darg)->OnStageConnectionSwigPublic(arg2);
63840       }
63841     } catch (std::out_of_range& e) {
63842       {
63843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63844       };
63845     } catch (std::exception& e) {
63846       {
63847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63848       };
63849     } catch (Dali::DaliException e) {
63850       {
63851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63852       };
63853     } catch (...) {
63854       {
63855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63856       };
63857     }
63858   }
63859
63860 }
63861
63862
63863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
63864   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63865   SwigDirector_ViewImpl *darg = 0;
63866
63867   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63868   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63869   if(!darg) {
63870     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63871     return;
63872   }
63873   {
63874     try {
63875       if(darg) {
63876         (darg)->OnStageDisconnection();
63877       }
63878     } catch (std::out_of_range& e) {
63879       {
63880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63881       };
63882     } catch (std::exception& e) {
63883       {
63884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63885       };
63886     } catch (Dali::DaliException e) {
63887       {
63888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63889       };
63890     } catch (...) {
63891       {
63892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63893       };
63894     }
63895   }
63896
63897 }
63898
63899
63900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
63901   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63902   SwigDirector_ViewImpl *darg = 0;
63903
63904   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63905   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63906   if(!darg) {
63907     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63908     return;
63909   }
63910   {
63911     try {
63912       if(darg) {
63913         (darg)->OnStageDisconnectionSwigPublic();
63914       }
63915     } catch (std::out_of_range& e) {
63916       {
63917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63918       };
63919     } catch (std::exception& e) {
63920       {
63921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63922       };
63923     } catch (Dali::DaliException e) {
63924       {
63925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63926       };
63927     } catch (...) {
63928       {
63929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63930       };
63931     }
63932   }
63933
63934 }
63935
63936
63937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
63938   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63939   Dali::Actor *arg2 = 0 ;
63940   SwigDirector_ViewImpl *darg = 0;
63941
63942   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63943   arg2 = (Dali::Actor *)jarg2;
63944   if (!arg2) {
63945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63946     return ;
63947   }
63948   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63949   if(!darg) {
63950     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63951     return;
63952   }
63953   {
63954     try {
63955       if(darg) {
63956         (darg)->OnChildAdd(*arg2);
63957       }
63958     } catch (std::out_of_range& e) {
63959       {
63960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63961       };
63962     } catch (std::exception& e) {
63963       {
63964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63965       };
63966     } catch (Dali::DaliException e) {
63967       {
63968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63969       };
63970     } catch (...) {
63971       {
63972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63973       };
63974     }
63975   }
63976
63977 }
63978
63979
63980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63981   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63982   Dali::Actor *arg2 = 0 ;
63983   SwigDirector_ViewImpl *darg = 0;
63984
63985   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63986   arg2 = (Dali::Actor *)jarg2;
63987   if (!arg2) {
63988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63989     return ;
63990   }
63991   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63992   if(!darg) {
63993     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63994     return;
63995   }
63996   {
63997     try {
63998       if(darg) {
63999           (darg)->OnChildAddSwigPublic(*arg2);
64000       }
64001     } catch (std::out_of_range& e) {
64002       {
64003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64004       };
64005     } catch (std::exception& e) {
64006       {
64007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64008       };
64009     } catch (Dali::DaliException e) {
64010       {
64011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64012       };
64013     } catch (...) {
64014       {
64015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64016       };
64017     }
64018   }
64019
64020 }
64021
64022
64023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
64024   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64025   Dali::Actor *arg2 = 0 ;
64026   SwigDirector_ViewImpl *darg = 0;
64027
64028   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64029   arg2 = (Dali::Actor *)jarg2;
64030   if (!arg2) {
64031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64032     return ;
64033   }
64034   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64035   if(!darg) {
64036     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64037     return;
64038   }
64039   {
64040     try {
64041       if(darg) {
64042         (darg)->OnChildRemove(*arg2);
64043       }
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_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64067   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64068   Dali::Actor *arg2 = 0 ;
64069   SwigDirector_ViewImpl *darg = 0;
64070
64071   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64072   arg2 = (Dali::Actor *)jarg2;
64073   if (!arg2) {
64074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64075     return ;
64076   }
64077   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64078   if(!darg) {
64079     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64080     return;
64081   }
64082   {
64083     try {
64084       if(darg) {
64085         (darg)->OnChildRemoveSwigPublic(*arg2);
64086       }
64087     } catch (std::out_of_range& e) {
64088       {
64089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64090       };
64091     } catch (std::exception& e) {
64092       {
64093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64094       };
64095     } catch (Dali::DaliException e) {
64096       {
64097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64098       };
64099     } catch (...) {
64100       {
64101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64102       };
64103     }
64104   }
64105
64106 }
64107
64108
64109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
64110   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64111   Dali::Property::Index arg2 ;
64112   Dali::Property::Value arg3 ;
64113   Dali::Property::Value *argp3 ;
64114   SwigDirector_ViewImpl *darg = 0;
64115
64116   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64117   arg2 = (Dali::Property::Index)jarg2;
64118   argp3 = (Dali::Property::Value *)jarg3;
64119   if (!argp3) {
64120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64121     return ;
64122   }
64123   arg3 = *argp3;
64124   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64125   if (!darg) {
64126     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64127     return;
64128   }
64129   {
64130     try {
64131       (darg)->OnPropertySet(arg2,arg3);
64132     } catch (std::out_of_range& e) {
64133       {
64134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64135       };
64136     } catch (std::exception& e) {
64137       {
64138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64139       };
64140     } catch (Dali::DaliException e) {
64141       {
64142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64143       };
64144     } catch (...) {
64145       {
64146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64147       };
64148     }
64149   }
64150
64151 }
64152
64153
64154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
64155   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64156   Dali::Property::Index arg2 ;
64157   Dali::Property::Value arg3 ;
64158   Dali::Property::Value *argp3 ;
64159   SwigDirector_ViewImpl *darg = 0;
64160
64161   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64162   arg2 = (Dali::Property::Index)jarg2;
64163   argp3 = (Dali::Property::Value *)jarg3;
64164   if (!argp3) {
64165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64166     return ;
64167   }
64168   arg3 = *argp3;
64169   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64170   if (!darg) {
64171     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64172     return;
64173   }
64174   {
64175     try {
64176       (darg)->OnPropertySetSwigPublic(arg2,arg3);
64177     } catch (std::out_of_range& e) {
64178       {
64179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64180       };
64181     } catch (std::exception& e) {
64182       {
64183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64184       };
64185     } catch (Dali::DaliException e) {
64186       {
64187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64188       };
64189     } catch (...) {
64190       {
64191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64192       };
64193     }
64194   }
64195
64196 }
64197
64198
64199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
64200   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64201   Dali::Vector3 *arg2 = 0 ;
64202   SwigDirector_ViewImpl *darg = 0;
64203
64204   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64205   arg2 = (Dali::Vector3 *)jarg2;
64206   if (!arg2) {
64207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64208     return ;
64209   }
64210   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64211   if (!darg) {
64212     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64213     return;
64214   }
64215   {
64216     try {
64217       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
64218     } catch (std::out_of_range& e) {
64219       {
64220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64221       };
64222     } catch (std::exception& e) {
64223       {
64224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64225       };
64226     } catch (Dali::DaliException e) {
64227       {
64228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64229       };
64230     } catch (...) {
64231       {
64232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64233       };
64234     }
64235   }
64236
64237 }
64238
64239
64240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64241   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64242   Dali::Vector3 *arg2 = 0 ;
64243   SwigDirector_ViewImpl *darg = 0;
64244
64245   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64246   arg2 = (Dali::Vector3 *)jarg2;
64247   if (!arg2) {
64248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64249     return ;
64250   }
64251   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64252   if (!darg) {
64253     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64254     return;
64255   }
64256   {
64257     try {
64258       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
64259     } catch (std::out_of_range& e) {
64260       {
64261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64262       };
64263     } catch (std::exception& e) {
64264       {
64265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64266       };
64267     } catch (Dali::DaliException e) {
64268       {
64269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64270       };
64271     } catch (...) {
64272       {
64273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64274       };
64275     }
64276   }
64277
64278 }
64279
64280
64281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
64282   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64283   Dali::Animation *arg2 = 0 ;
64284   Dali::Vector3 *arg3 = 0 ;
64285   SwigDirector_ViewImpl *darg = 0;
64286
64287   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64288   arg2 = (Dali::Animation *)jarg2;
64289   if (!arg2) {
64290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64291     return ;
64292   }
64293   arg3 = (Dali::Vector3 *)jarg3;
64294   if (!arg3) {
64295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64296     return ;
64297   }
64298   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64299   if (!darg) {
64300     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64301     return;
64302   }
64303   {
64304     try {
64305       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
64306     } catch (std::out_of_range& e) {
64307       {
64308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64309       };
64310     } catch (std::exception& e) {
64311       {
64312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64313       };
64314     } catch (Dali::DaliException e) {
64315       {
64316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64317       };
64318     } catch (...) {
64319       {
64320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64321       };
64322     }
64323   }
64324
64325 }
64326
64327
64328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64329   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64330   Dali::Animation *arg2 = 0 ;
64331   Dali::Vector3 *arg3 = 0 ;
64332   SwigDirector_ViewImpl *darg = 0;
64333
64334   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64335   arg2 = (Dali::Animation *)jarg2;
64336   if (!arg2) {
64337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64338     return ;
64339   }
64340   arg3 = (Dali::Vector3 *)jarg3;
64341   if (!arg3) {
64342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64343     return ;
64344   }
64345   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64346   if (!darg) {
64347     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64348     return;
64349   }
64350   {
64351     try {
64352       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64353     } catch (std::out_of_range& e) {
64354       {
64355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64356       };
64357     } catch (std::exception& e) {
64358       {
64359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64360       };
64361     } catch (Dali::DaliException e) {
64362       {
64363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64364       };
64365     } catch (...) {
64366       {
64367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64368       };
64369     }
64370   }
64371
64372 }
64373
64374
64375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64376   unsigned int jresult ;
64377   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64378   Dali::TouchEvent *arg2 = 0 ;
64379   SwigDirector_ViewImpl *darg = 0;
64380   bool result;
64381
64382   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64383   arg2 = (Dali::TouchEvent *)jarg2;
64384   if (!arg2) {
64385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64386     return 0;
64387   }
64388   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64389   if (!darg) {
64390     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64391     return 0;
64392   }
64393   {
64394     try {
64395       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64396     } catch (std::out_of_range& e) {
64397       {
64398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64399       };
64400     } catch (std::exception& e) {
64401       {
64402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64403       };
64404     } catch (Dali::DaliException e) {
64405       {
64406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64407       };
64408     } catch (...) {
64409       {
64410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64411       };
64412     }
64413   }
64414
64415   jresult = result;
64416   return jresult;
64417 }
64418
64419
64420 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64421   unsigned int jresult ;
64422   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64423   Dali::TouchEvent *arg2 = 0 ;
64424   SwigDirector_ViewImpl *darg = 0;
64425   bool result;
64426
64427   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64428   arg2 = (Dali::TouchEvent *)jarg2;
64429   if (!arg2) {
64430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64431     return 0;
64432   }
64433   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64434   if (!darg) {
64435     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64436     return 0;
64437   }
64438   {
64439     try {
64440       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
64441     } catch (std::out_of_range& e) {
64442       {
64443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64444       };
64445     } catch (std::exception& e) {
64446       {
64447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64448       };
64449     } catch (Dali::DaliException e) {
64450       {
64451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64452       };
64453     } catch (...) {
64454       {
64455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64456       };
64457     }
64458   }
64459
64460   jresult = result;
64461   return jresult;
64462 }
64463
64464
64465 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
64466   unsigned int jresult ;
64467   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64468   Dali::HoverEvent *arg2 = 0 ;
64469   SwigDirector_ViewImpl *darg = 0;
64470   bool result;
64471
64472   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64473   arg2 = (Dali::HoverEvent *)jarg2;
64474   if (!arg2) {
64475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64476     return 0;
64477   }
64478   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64479   if (!darg) {
64480     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64481     return 0;
64482   }
64483   {
64484     try {
64485       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
64486     } catch (std::out_of_range& e) {
64487       {
64488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64489       };
64490     } catch (std::exception& e) {
64491       {
64492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64493       };
64494     } catch (Dali::DaliException e) {
64495       {
64496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64497       };
64498     } catch (...) {
64499       {
64500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64501       };
64502     }
64503   }
64504
64505   jresult = result;
64506   return jresult;
64507 }
64508
64509
64510 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64511   unsigned int jresult ;
64512   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64513   Dali::HoverEvent *arg2 = 0 ;
64514   SwigDirector_ViewImpl *darg = 0;
64515   bool result;
64516
64517   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64518   arg2 = (Dali::HoverEvent *)jarg2;
64519   if (!arg2) {
64520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64521     return 0;
64522   }
64523   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64524   if (!darg) {
64525     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64526     return 0;
64527   }
64528   {
64529     try {
64530       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
64531     } catch (std::out_of_range& e) {
64532       {
64533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64534       };
64535     } catch (std::exception& e) {
64536       {
64537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64538       };
64539     } catch (Dali::DaliException e) {
64540       {
64541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64542       };
64543     } catch (...) {
64544       {
64545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64546       };
64547     }
64548   }
64549
64550   jresult = result;
64551   return jresult;
64552 }
64553
64554
64555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
64556   unsigned int jresult ;
64557   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64558   Dali::KeyEvent *arg2 = 0 ;
64559   SwigDirector_ViewImpl *darg = 0;
64560   bool result;
64561
64562   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64563   arg2 = (Dali::KeyEvent *)jarg2;
64564   if (!arg2) {
64565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64566     return 0;
64567   }
64568   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64569   if (!darg) {
64570     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64571     return 0;
64572   }
64573   {
64574     try {
64575       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
64576     } catch (std::out_of_range& e) {
64577       {
64578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64579       };
64580     } catch (std::exception& e) {
64581       {
64582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64583       };
64584     } catch (Dali::DaliException e) {
64585       {
64586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64587       };
64588     } catch (...) {
64589       {
64590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64591       };
64592     }
64593   }
64594
64595   jresult = result;
64596   return jresult;
64597 }
64598
64599
64600 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64601   unsigned int jresult ;
64602   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64603   Dali::KeyEvent *arg2 = 0 ;
64604   SwigDirector_ViewImpl *darg = 0;
64605   bool result;
64606
64607   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64608   arg2 = (Dali::KeyEvent *)jarg2;
64609   if (!arg2) {
64610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64611     return 0;
64612   }
64613   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64614   if (!darg) {
64615     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64616     return 0;
64617   }
64618   {
64619     try {
64620       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
64621     } catch (std::out_of_range& e) {
64622       {
64623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64624       };
64625     } catch (std::exception& e) {
64626       {
64627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64628       };
64629     } catch (Dali::DaliException e) {
64630       {
64631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64632       };
64633     } catch (...) {
64634       {
64635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64636       };
64637     }
64638   }
64639
64640   jresult = result;
64641   return jresult;
64642 }
64643
64644
64645 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
64646   unsigned int jresult ;
64647   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64648   Dali::WheelEvent *arg2 = 0 ;
64649   SwigDirector_ViewImpl *darg = 0;
64650   bool result;
64651
64652   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64653   arg2 = (Dali::WheelEvent *)jarg2;
64654   if (!arg2) {
64655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64656     return 0;
64657   }
64658   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64659   if (!darg) {
64660     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64661     return 0;
64662   }
64663   {
64664     try {
64665       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
64666     } catch (std::out_of_range& e) {
64667       {
64668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64669       };
64670     } catch (std::exception& e) {
64671       {
64672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64673       };
64674     } catch (Dali::DaliException e) {
64675       {
64676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64677       };
64678     } catch (...) {
64679       {
64680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64681       };
64682     }
64683   }
64684
64685   jresult = result;
64686   return jresult;
64687 }
64688
64689
64690 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64691   unsigned int jresult ;
64692   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64693   Dali::WheelEvent *arg2 = 0 ;
64694   SwigDirector_ViewImpl *darg = 0;
64695   bool result;
64696
64697   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64698   arg2 = (Dali::WheelEvent *)jarg2;
64699   if (!arg2) {
64700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64701     return 0;
64702   }
64703   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64704   if (!darg) {
64705     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64706     return 0;
64707   }
64708   {
64709     try {
64710       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
64711     } catch (std::out_of_range& e) {
64712       {
64713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64714       };
64715     } catch (std::exception& e) {
64716       {
64717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64718       };
64719     } catch (Dali::DaliException e) {
64720       {
64721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64722       };
64723     } catch (...) {
64724       {
64725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64726       };
64727     }
64728   }
64729
64730   jresult = result;
64731   return jresult;
64732 }
64733
64734
64735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
64736   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64737   Dali::Vector2 *arg2 = 0 ;
64738   Dali::RelayoutContainer *arg3 = 0 ;
64739   SwigDirector_ViewImpl *darg = 0;
64740
64741   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64742   arg2 = (Dali::Vector2 *)jarg2;
64743   if (!arg2) {
64744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64745     return ;
64746   }
64747   arg3 = (Dali::RelayoutContainer *)jarg3;
64748   if (!arg3) {
64749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64750     return ;
64751   }
64752   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64753   if (!darg) {
64754     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64755     return;
64756   }
64757   {
64758     try {
64759       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
64760     } catch (std::out_of_range& e) {
64761       {
64762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64763       };
64764     } catch (std::exception& e) {
64765       {
64766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64767       };
64768     } catch (Dali::DaliException e) {
64769       {
64770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64771       };
64772     } catch (...) {
64773       {
64774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64775       };
64776     }
64777   }
64778
64779 }
64780
64781
64782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64783   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64784   Dali::Vector2 *arg2 = 0 ;
64785   Dali::RelayoutContainer *arg3 = 0 ;
64786   SwigDirector_ViewImpl *darg = 0;
64787
64788   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64789   arg2 = (Dali::Vector2 *)jarg2;
64790   if (!arg2) {
64791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64792     return ;
64793   }
64794   arg3 = (Dali::RelayoutContainer *)jarg3;
64795   if (!arg3) {
64796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64797     return ;
64798   }
64799   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64800   if (!darg) {
64801     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64802     return;
64803   }
64804   {
64805     try {
64806       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
64807     } catch (std::out_of_range& e) {
64808       {
64809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64810       };
64811     } catch (std::exception& e) {
64812       {
64813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64814       };
64815     } catch (Dali::DaliException e) {
64816       {
64817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64818       };
64819     } catch (...) {
64820       {
64821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64822       };
64823     }
64824   }
64825
64826 }
64827
64828
64829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
64830   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64831   Dali::ResizePolicy::Type arg2 ;
64832   Dali::Dimension::Type arg3 ;
64833   SwigDirector_ViewImpl *darg = 0;
64834
64835   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64836   arg2 = (Dali::ResizePolicy::Type)jarg2;
64837   arg3 = (Dali::Dimension::Type)jarg3;
64838   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64839   if (!darg) {
64840     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64841     return;
64842   }
64843   {
64844     try {
64845       (darg)->OnSetResizePolicy(arg2,arg3);
64846     } catch (std::out_of_range& e) {
64847       {
64848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64849       };
64850     } catch (std::exception& e) {
64851       {
64852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64853       };
64854     } catch (Dali::DaliException e) {
64855       {
64856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64857       };
64858     } catch (...) {
64859       {
64860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64861       };
64862     }
64863   }
64864
64865 }
64866
64867
64868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
64869   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64870   Dali::ResizePolicy::Type arg2 ;
64871   Dali::Dimension::Type arg3 ;
64872   SwigDirector_ViewImpl *darg = 0;
64873
64874   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64875   arg2 = (Dali::ResizePolicy::Type)jarg2;
64876   arg3 = (Dali::Dimension::Type)jarg3;
64877   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64878   if (!darg) {
64879     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64880     return;
64881   }
64882   {
64883     try {
64884       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
64885     } catch (std::out_of_range& e) {
64886       {
64887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64888       };
64889     } catch (std::exception& e) {
64890       {
64891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64892       };
64893     } catch (Dali::DaliException e) {
64894       {
64895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64896       };
64897     } catch (...) {
64898       {
64899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64900       };
64901     }
64902   }
64903
64904 }
64905
64906
64907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
64908   void * jresult ;
64909   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64910   SwigDirector_ViewImpl *darg = 0;
64911   Dali::Vector3 result;
64912
64913   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64914   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64915   if (!darg) {
64916     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64917     return 0;
64918   }
64919   {
64920     try {
64921       result = (darg)->GetNaturalSize();
64922     } catch (std::out_of_range& e) {
64923       {
64924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64925       };
64926     } catch (std::exception& e) {
64927       {
64928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64929       };
64930     } catch (Dali::DaliException e) {
64931       {
64932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64933       };
64934     } catch (...) {
64935       {
64936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64937       };
64938     }
64939   }
64940
64941   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
64942   return jresult;
64943 }
64944
64945
64946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
64947   void * jresult ;
64948   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64949   SwigDirector_ViewImpl *darg = 0;
64950   Dali::Vector3 result;
64951
64952   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64953   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64954   if (!darg) {
64955     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64956     return 0;
64957   }
64958   {
64959     try {
64960       result = (darg)->GetNaturalSizeSwigPublic();
64961     } catch (std::out_of_range& e) {
64962       {
64963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64964       };
64965     } catch (std::exception& e) {
64966       {
64967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64968       };
64969     } catch (Dali::DaliException e) {
64970       {
64971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64972       };
64973     } catch (...) {
64974       {
64975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64976       };
64977     }
64978   }
64979
64980   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
64981   return jresult;
64982 }
64983
64984
64985 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
64986   float jresult ;
64987   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64988   Dali::Actor *arg2 = 0 ;
64989   Dali::Dimension::Type arg3 ;
64990   SwigDirector_ViewImpl *darg = 0;
64991   float result;
64992
64993   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64994   arg2 = (Dali::Actor *)jarg2;
64995   if (!arg2) {
64996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
64997     return 0;
64998   }
64999   arg3 = (Dali::Dimension::Type)jarg3;
65000   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65001   if (!darg) {
65002     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65003     return 0;
65004   }
65005   {
65006     try {
65007       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
65008     } catch (std::out_of_range& e) {
65009       {
65010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65011       };
65012     } catch (std::exception& e) {
65013       {
65014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65015       };
65016     } catch (Dali::DaliException e) {
65017       {
65018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65019       };
65020     } catch (...) {
65021       {
65022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65023       };
65024     }
65025   }
65026
65027   jresult = result;
65028   return jresult;
65029 }
65030
65031
65032 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65033   float jresult ;
65034   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65035   Dali::Actor *arg2 = 0 ;
65036   Dali::Dimension::Type arg3 ;
65037   SwigDirector_ViewImpl *darg = 0;
65038   float result;
65039
65040   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65041   arg2 = (Dali::Actor *)jarg2;
65042   if (!arg2) {
65043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65044     return 0;
65045   }
65046   arg3 = (Dali::Dimension::Type)jarg3;
65047   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65048   if (!darg) {
65049     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65050     return 0;
65051   }
65052   {
65053     try {
65054       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
65055     } catch (std::out_of_range& e) {
65056       {
65057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65058       };
65059     } catch (std::exception& e) {
65060       {
65061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65062       };
65063     } catch (Dali::DaliException e) {
65064       {
65065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65066       };
65067     } catch (...) {
65068       {
65069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65070       };
65071     }
65072   }
65073
65074   jresult = result;
65075   return jresult;
65076 }
65077
65078
65079 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
65080   float jresult ;
65081   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65082   float arg2 ;
65083   SwigDirector_ViewImpl *darg = 0;
65084   float result;
65085
65086   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65087   arg2 = (float)jarg2;
65088   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65089   if (!darg) {
65090     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65091     return 0;
65092   }
65093   {
65094     try {
65095       result = (float)(darg)->GetHeightForWidth(arg2);
65096     } catch (std::out_of_range& e) {
65097       {
65098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65099       };
65100     } catch (std::exception& e) {
65101       {
65102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65103       };
65104     } catch (Dali::DaliException e) {
65105       {
65106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65107       };
65108     } catch (...) {
65109       {
65110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65111       };
65112     }
65113   }
65114
65115   jresult = result;
65116   return jresult;
65117 }
65118
65119
65120 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
65121   float jresult ;
65122   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65123   float arg2 ;
65124   SwigDirector_ViewImpl *darg = 0;
65125   float result;
65126
65127   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65128   arg2 = (float)jarg2;
65129   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65130   if (!darg) {
65131     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65132     return 0;
65133   }
65134   {
65135     try {
65136       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
65137     } catch (std::out_of_range& e) {
65138       {
65139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65140       };
65141     } catch (std::exception& e) {
65142       {
65143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65144       };
65145     } catch (Dali::DaliException e) {
65146       {
65147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65148       };
65149     } catch (...) {
65150       {
65151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65152       };
65153     }
65154   }
65155
65156   jresult = result;
65157   return jresult;
65158 }
65159
65160
65161 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
65162   float jresult ;
65163   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65164   float arg2 ;
65165   SwigDirector_ViewImpl *darg = 0;
65166   float result;
65167
65168   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65169   arg2 = (float)jarg2;
65170   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65171   if (!darg) {
65172     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65173     return 0;
65174   }
65175   {
65176     try {
65177       result = (float)(darg)->GetWidthForHeight(arg2);
65178     } catch (std::out_of_range& e) {
65179       {
65180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65181       };
65182     } catch (std::exception& e) {
65183       {
65184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65185       };
65186     } catch (Dali::DaliException e) {
65187       {
65188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65189       };
65190     } catch (...) {
65191       {
65192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65193       };
65194     }
65195   }
65196
65197   jresult = result;
65198   return jresult;
65199 }
65200
65201
65202 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
65203   float jresult ;
65204   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65205   float arg2 ;
65206   SwigDirector_ViewImpl *darg = 0;
65207   float result;
65208
65209   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65210   arg2 = (float)jarg2;
65211   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65212   if (!darg) {
65213     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65214     return 0;
65215   }
65216   {
65217     try {
65218       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
65219     } catch (std::out_of_range& e) {
65220       {
65221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65222       };
65223     } catch (std::exception& e) {
65224       {
65225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65226       };
65227     } catch (Dali::DaliException e) {
65228       {
65229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65230       };
65231     } catch (...) {
65232       {
65233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65234       };
65235     }
65236   }
65237
65238   jresult = result;
65239   return jresult;
65240 }
65241
65242
65243 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
65244   unsigned int jresult ;
65245   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65246   Dali::Dimension::Type arg2 ;
65247   SwigDirector_ViewImpl *darg = 0;
65248   bool result;
65249
65250   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65251   arg2 = (Dali::Dimension::Type)jarg2;
65252   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65253   if (!darg) {
65254     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65255     return 0;
65256   }
65257   {
65258     try {
65259       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
65260     } catch (std::out_of_range& e) {
65261       {
65262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65263       };
65264     } catch (std::exception& e) {
65265       {
65266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65267       };
65268     } catch (Dali::DaliException e) {
65269       {
65270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65271       };
65272     } catch (...) {
65273       {
65274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65275       };
65276     }
65277   }
65278
65279   jresult = result;
65280   return jresult;
65281 }
65282
65283
65284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
65285   unsigned int jresult ;
65286   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65287   Dali::Dimension::Type arg2 ;
65288   SwigDirector_ViewImpl *darg = 0;
65289   bool result;
65290
65291   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65292   arg2 = (Dali::Dimension::Type)jarg2;
65293   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65294   if (!darg) {
65295     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65296     return 0;
65297   }
65298   {
65299     try {
65300       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
65301     } catch (std::out_of_range& e) {
65302       {
65303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65304       };
65305     } catch (std::exception& e) {
65306       {
65307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65308       };
65309     } catch (Dali::DaliException e) {
65310       {
65311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65312       };
65313     } catch (...) {
65314       {
65315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65316       };
65317     }
65318   }
65319
65320   jresult = result;
65321   return jresult;
65322 }
65323
65324
65325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65326   unsigned int jresult ;
65327   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65328   SwigDirector_ViewImpl *darg = 0;
65329   bool result;
65330
65331   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65332   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65333   if (!darg) {
65334     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65335     return 0;
65336   }
65337   {
65338     try {
65339       result = (bool)(darg)->RelayoutDependentOnChildren();
65340     } catch (std::out_of_range& e) {
65341       {
65342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65343       };
65344     } catch (std::exception& e) {
65345       {
65346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65347       };
65348     } catch (Dali::DaliException e) {
65349       {
65350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65351       };
65352     } catch (...) {
65353       {
65354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65355       };
65356     }
65357   }
65358
65359   jresult = result;
65360   return jresult;
65361 }
65362
65363
65364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
65365   unsigned int jresult ;
65366   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65367   SwigDirector_ViewImpl *darg = 0;
65368   bool result;
65369
65370   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65371   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65372   if (!darg) {
65373     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65374     return 0;
65375   }
65376   {
65377     try {
65378       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
65379     } catch (std::out_of_range& e) {
65380       {
65381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65382       };
65383     } catch (std::exception& e) {
65384       {
65385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65386       };
65387     } catch (Dali::DaliException e) {
65388       {
65389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65390       };
65391     } catch (...) {
65392       {
65393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65394       };
65395     }
65396   }
65397
65398   jresult = result;
65399   return jresult;
65400 }
65401
65402
65403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65404   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65405   Dali::Dimension::Type arg2 ;
65406   SwigDirector_ViewImpl *darg = 0;
65407
65408   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65409   arg2 = (Dali::Dimension::Type)jarg2;
65410   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65411   if (!darg) {
65412     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65413     return;
65414   }
65415   {
65416     try {
65417       (darg)->OnCalculateRelayoutSize(arg2);
65418     } catch (std::out_of_range& e) {
65419       {
65420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65421       };
65422     } catch (std::exception& e) {
65423       {
65424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65425       };
65426     } catch (Dali::DaliException e) {
65427       {
65428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65429       };
65430     } catch (...) {
65431       {
65432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65433       };
65434     }
65435   }
65436
65437 }
65438
65439
65440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
65441   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65442   Dali::Dimension::Type arg2 ;
65443   SwigDirector_ViewImpl *darg = 0;
65444
65445   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65446   arg2 = (Dali::Dimension::Type)jarg2;
65447   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65448   if (!darg) {
65449     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65450     return;
65451   }
65452   {
65453     try {
65454       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
65455     } catch (std::out_of_range& e) {
65456       {
65457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65458       };
65459     } catch (std::exception& e) {
65460       {
65461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65462       };
65463     } catch (Dali::DaliException e) {
65464       {
65465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65466       };
65467     } catch (...) {
65468       {
65469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65470       };
65471     }
65472   }
65473
65474 }
65475
65476
65477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
65478   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65479   float arg2 ;
65480   Dali::Dimension::Type arg3 ;
65481   SwigDirector_ViewImpl *darg = 0;
65482
65483   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65484   arg2 = (float)jarg2;
65485   arg3 = (Dali::Dimension::Type)jarg3;
65486   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65487   if (!darg) {
65488     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65489     return;
65490   }
65491   {
65492     try {
65493       (darg)->OnLayoutNegotiated(arg2,arg3);
65494     } catch (std::out_of_range& e) {
65495       {
65496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65497       };
65498     } catch (std::exception& e) {
65499       {
65500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65501       };
65502     } catch (Dali::DaliException e) {
65503       {
65504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65505       };
65506     } catch (...) {
65507       {
65508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65509       };
65510     }
65511   }
65512
65513 }
65514
65515
65516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
65517   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65518   float arg2 ;
65519   Dali::Dimension::Type arg3 ;
65520   SwigDirector_ViewImpl *darg = 0;
65521
65522   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65523   arg2 = (float)jarg2;
65524   arg3 = (Dali::Dimension::Type)jarg3;
65525   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65526   if (!darg) {
65527     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65528     return;
65529   }
65530   {
65531     try {
65532       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
65533     } catch (std::out_of_range& e) {
65534       {
65535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65536       };
65537     } catch (std::exception& e) {
65538       {
65539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65540       };
65541     } catch (Dali::DaliException e) {
65542       {
65543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65544       };
65545     } catch (...) {
65546       {
65547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65548       };
65549     }
65550   }
65551
65552 }
65553
65554
65555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
65556   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65557
65558   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65559   {
65560     try {
65561       (arg1)->OnInitialize();
65562     } catch (std::out_of_range& e) {
65563       {
65564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65565       };
65566     } catch (std::exception& e) {
65567       {
65568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65569       };
65570     } catch (Dali::DaliException e) {
65571       {
65572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65573       };
65574     } catch (...) {
65575       {
65576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65577       };
65578     }
65579   }
65580
65581 }
65582
65583
65584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
65585   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65586
65587   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65588   {
65589     try {
65590       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
65591     } catch (std::out_of_range& e) {
65592       {
65593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65594       };
65595     } catch (std::exception& e) {
65596       {
65597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65598       };
65599     } catch (Dali::DaliException e) {
65600       {
65601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65602       };
65603     } catch (...) {
65604       {
65605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65606       };
65607     }
65608   }
65609
65610 }
65611
65612
65613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
65614   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65615   Dali::Actor *arg2 = 0 ;
65616
65617   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65618   arg2 = (Dali::Actor *)jarg2;
65619   if (!arg2) {
65620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65621     return ;
65622   }
65623   {
65624     try {
65625       (arg1)->OnControlChildAdd(*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_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65649   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65650   Dali::Actor *arg2 = 0 ;
65651
65652   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65653   arg2 = (Dali::Actor *)jarg2;
65654   if (!arg2) {
65655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65656     return ;
65657   }
65658   {
65659     try {
65660       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
65661     } catch (std::out_of_range& e) {
65662       {
65663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65664       };
65665     } catch (std::exception& e) {
65666       {
65667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65668       };
65669     } catch (Dali::DaliException e) {
65670       {
65671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65672       };
65673     } catch (...) {
65674       {
65675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65676       };
65677     }
65678   }
65679
65680 }
65681
65682
65683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
65684   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65685   Dali::Actor *arg2 = 0 ;
65686
65687   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65688   arg2 = (Dali::Actor *)jarg2;
65689   if (!arg2) {
65690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65691     return ;
65692   }
65693   {
65694     try {
65695       (arg1)->OnControlChildRemove(*arg2);
65696     } catch (std::out_of_range& e) {
65697       {
65698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65699       };
65700     } catch (std::exception& e) {
65701       {
65702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65703       };
65704     } catch (Dali::DaliException e) {
65705       {
65706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65707       };
65708     } catch (...) {
65709       {
65710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65711       };
65712     }
65713   }
65714
65715 }
65716
65717
65718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65719   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65720   Dali::Actor *arg2 = 0 ;
65721
65722   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65723   arg2 = (Dali::Actor *)jarg2;
65724   if (!arg2) {
65725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65726     return ;
65727   }
65728   {
65729     try {
65730       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
65731     } catch (std::out_of_range& e) {
65732       {
65733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65734       };
65735     } catch (std::exception& e) {
65736       {
65737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65738       };
65739     } catch (Dali::DaliException e) {
65740       {
65741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65742       };
65743     } catch (...) {
65744       {
65745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65746       };
65747     }
65748   }
65749
65750 }
65751
65752
65753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
65754   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65755   Dali::Toolkit::StyleManager arg2 ;
65756   Dali::StyleChange::Type arg3 ;
65757   Dali::Toolkit::StyleManager *argp2 ;
65758
65759   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65760   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65761   if (!argp2) {
65762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65763     return ;
65764   }
65765   arg2 = *argp2;
65766   arg3 = (Dali::StyleChange::Type)jarg3;
65767   {
65768     try {
65769       (arg1)->OnStyleChange(arg2,arg3);
65770     } catch (std::out_of_range& e) {
65771       {
65772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65773       };
65774     } catch (std::exception& e) {
65775       {
65776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65777       };
65778     } catch (Dali::DaliException e) {
65779       {
65780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65781       };
65782     } catch (...) {
65783       {
65784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65785       };
65786     }
65787   }
65788
65789 }
65790
65791
65792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65793   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65794   Dali::Toolkit::StyleManager arg2 ;
65795   Dali::StyleChange::Type arg3 ;
65796   Dali::Toolkit::StyleManager *argp2 ;
65797
65798   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65799   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65800   if (!argp2) {
65801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65802     return ;
65803   }
65804   arg2 = *argp2;
65805   arg3 = (Dali::StyleChange::Type)jarg3;
65806   {
65807     try {
65808       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
65809     } catch (std::out_of_range& e) {
65810       {
65811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65812       };
65813     } catch (std::exception& e) {
65814       {
65815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65816       };
65817     } catch (Dali::DaliException e) {
65818       {
65819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65820       };
65821     } catch (...) {
65822       {
65823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65824       };
65825     }
65826   }
65827
65828 }
65829
65830
65831 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
65832   unsigned int jresult ;
65833   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65834   bool result;
65835
65836   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65837   {
65838     try {
65839       result = (bool)(arg1)->OnAccessibilityActivated();
65840     } catch (std::out_of_range& e) {
65841       {
65842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65843       };
65844     } catch (std::exception& e) {
65845       {
65846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65847       };
65848     } catch (Dali::DaliException e) {
65849       {
65850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65851       };
65852     } catch (...) {
65853       {
65854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65855       };
65856     }
65857   }
65858
65859   jresult = result;
65860   return jresult;
65861 }
65862
65863
65864 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
65865   unsigned int jresult ;
65866   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65867   bool result;
65868
65869   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65870   {
65871     try {
65872       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
65873     } catch (std::out_of_range& e) {
65874       {
65875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65876       };
65877     } catch (std::exception& e) {
65878       {
65879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65880       };
65881     } catch (Dali::DaliException e) {
65882       {
65883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65884       };
65885     } catch (...) {
65886       {
65887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65888       };
65889     }
65890   }
65891
65892   jresult = result;
65893   return jresult;
65894 }
65895
65896
65897 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
65898   unsigned int jresult ;
65899   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65900   Dali::PanGesture arg2 ;
65901   Dali::PanGesture *argp2 ;
65902   bool result;
65903
65904   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65905   argp2 = (Dali::PanGesture *)jarg2;
65906   if (!argp2) {
65907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
65908     return 0;
65909   }
65910   arg2 = *argp2;
65911   {
65912     try {
65913       result = (bool)(arg1)->OnAccessibilityPan(arg2);
65914     } catch (std::out_of_range& e) {
65915       {
65916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65917       };
65918     } catch (std::exception& e) {
65919       {
65920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65921       };
65922     } catch (Dali::DaliException e) {
65923       {
65924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65925       };
65926     } catch (...) {
65927       {
65928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65929       };
65930     }
65931   }
65932
65933   jresult = result;
65934   return jresult;
65935 }
65936
65937
65938 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65939   unsigned int jresult ;
65940   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65941   Dali::PanGesture arg2 ;
65942   Dali::PanGesture *argp2 ;
65943   bool result;
65944
65945   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65946   argp2 = (Dali::PanGesture *)jarg2;
65947   if (!argp2) {
65948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
65949     return 0;
65950   }
65951   arg2 = *argp2;
65952   {
65953     try {
65954       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
65955     } catch (std::out_of_range& e) {
65956       {
65957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65958       };
65959     } catch (std::exception& e) {
65960       {
65961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65962       };
65963     } catch (Dali::DaliException e) {
65964       {
65965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65966       };
65967     } catch (...) {
65968       {
65969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65970       };
65971     }
65972   }
65973
65974   jresult = result;
65975   return jresult;
65976 }
65977
65978
65979 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
65980   unsigned int jresult ;
65981   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65982   Dali::TouchEvent *arg2 = 0 ;
65983   bool result;
65984
65985   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65986   arg2 = (Dali::TouchEvent *)jarg2;
65987   if (!arg2) {
65988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
65989     return 0;
65990   }
65991   {
65992     try {
65993       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
65994     } catch (std::out_of_range& e) {
65995       {
65996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65997       };
65998     } catch (std::exception& e) {
65999       {
66000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66001       };
66002     } catch (Dali::DaliException e) {
66003       {
66004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66005       };
66006     } catch (...) {
66007       {
66008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66009       };
66010     }
66011   }
66012
66013   jresult = result;
66014   return jresult;
66015 }
66016
66017
66018 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66019   unsigned int jresult ;
66020   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66021   Dali::TouchEvent *arg2 = 0 ;
66022   bool result;
66023
66024   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66025   arg2 = (Dali::TouchEvent *)jarg2;
66026   if (!arg2) {
66027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66028     return 0;
66029   }
66030   {
66031     try {
66032       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66033     } catch (std::out_of_range& e) {
66034       {
66035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66036       };
66037     } catch (std::exception& e) {
66038       {
66039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66040       };
66041     } catch (Dali::DaliException e) {
66042       {
66043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66044       };
66045     } catch (...) {
66046       {
66047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66048       };
66049     }
66050   }
66051
66052   jresult = result;
66053   return jresult;
66054 }
66055
66056
66057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
66058   unsigned int jresult ;
66059   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66060   bool arg2 ;
66061   bool result;
66062
66063   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66064   arg2 = jarg2 ? true : false;
66065   {
66066     try {
66067       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
66068     } catch (std::out_of_range& e) {
66069       {
66070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66071       };
66072     } catch (std::exception& e) {
66073       {
66074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66075       };
66076     } catch (Dali::DaliException e) {
66077       {
66078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66079       };
66080     } catch (...) {
66081       {
66082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66083       };
66084     }
66085   }
66086
66087   jresult = result;
66088   return jresult;
66089 }
66090
66091
66092 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
66093   unsigned int jresult ;
66094   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66095   bool arg2 ;
66096   bool result;
66097
66098   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66099   arg2 = jarg2 ? true : false;
66100   {
66101     try {
66102       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
66103     } catch (std::out_of_range& e) {
66104       {
66105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66106       };
66107     } catch (std::exception& e) {
66108       {
66109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66110       };
66111     } catch (Dali::DaliException e) {
66112       {
66113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66114       };
66115     } catch (...) {
66116       {
66117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66118       };
66119     }
66120   }
66121
66122   jresult = result;
66123   return jresult;
66124 }
66125
66126
66127 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
66128   unsigned int jresult ;
66129   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66130   bool result;
66131
66132   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66133   {
66134     try {
66135       result = (bool)(arg1)->OnAccessibilityZoom();
66136     } catch (std::out_of_range& e) {
66137       {
66138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66139       };
66140     } catch (std::exception& e) {
66141       {
66142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66143       };
66144     } catch (Dali::DaliException e) {
66145       {
66146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66147       };
66148     } catch (...) {
66149       {
66150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66151       };
66152     }
66153   }
66154
66155   jresult = result;
66156   return jresult;
66157 }
66158
66159
66160 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
66161   unsigned int jresult ;
66162   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66163   bool result;
66164
66165   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66166   {
66167     try {
66168       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
66169     } catch (std::out_of_range& e) {
66170       {
66171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66172       };
66173     } catch (std::exception& e) {
66174       {
66175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66176       };
66177     } catch (Dali::DaliException e) {
66178       {
66179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66180       };
66181     } catch (...) {
66182       {
66183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66184       };
66185     }
66186   }
66187
66188   jresult = result;
66189   return jresult;
66190 }
66191
66192
66193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
66194   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66195
66196   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66197   {
66198     try {
66199       (arg1)->OnKeyInputFocusGained();
66200     } catch (std::out_of_range& e) {
66201       {
66202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66203       };
66204     } catch (std::exception& e) {
66205       {
66206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66207       };
66208     } catch (Dali::DaliException e) {
66209       {
66210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66211       };
66212     } catch (...) {
66213       {
66214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66215       };
66216     }
66217   }
66218
66219 }
66220
66221
66222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
66223   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66224
66225   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66226   {
66227     try {
66228       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
66229     } catch (std::out_of_range& e) {
66230       {
66231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66232       };
66233     } catch (std::exception& e) {
66234       {
66235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66236       };
66237     } catch (Dali::DaliException e) {
66238       {
66239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66240       };
66241     } catch (...) {
66242       {
66243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66244       };
66245     }
66246   }
66247
66248 }
66249
66250
66251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
66252   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66253
66254   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66255   {
66256     try {
66257       (arg1)->OnKeyInputFocusLost();
66258     } catch (std::out_of_range& e) {
66259       {
66260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66261       };
66262     } catch (std::exception& e) {
66263       {
66264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66265       };
66266     } catch (Dali::DaliException e) {
66267       {
66268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66269       };
66270     } catch (...) {
66271       {
66272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66273       };
66274     }
66275   }
66276
66277 }
66278
66279
66280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
66281   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66282
66283   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66284   {
66285     try {
66286       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
66287     } catch (std::out_of_range& e) {
66288       {
66289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66290       };
66291     } catch (std::exception& e) {
66292       {
66293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66294       };
66295     } catch (Dali::DaliException e) {
66296       {
66297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66298       };
66299     } catch (...) {
66300       {
66301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66302       };
66303     }
66304   }
66305
66306 }
66307
66308
66309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66310   void * jresult ;
66311   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66312   Dali::Actor arg2 ;
66313   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66314   bool arg4 ;
66315   Dali::Actor *argp2 ;
66316   Dali::Actor result;
66317
66318   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66319   argp2 = (Dali::Actor *)jarg2;
66320   if (!argp2) {
66321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66322     return 0;
66323   }
66324   arg2 = *argp2;
66325   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66326   arg4 = jarg4 ? true : false;
66327   {
66328     try {
66329       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66330     } catch (std::out_of_range& e) {
66331       {
66332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66333       };
66334     } catch (std::exception& e) {
66335       {
66336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66337       };
66338     } catch (Dali::DaliException e) {
66339       {
66340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66341       };
66342     } catch (...) {
66343       {
66344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66345       };
66346     }
66347   }
66348
66349   jresult = new Dali::Actor((const Dali::Actor &)result);
66350   return jresult;
66351 }
66352
66353
66354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66355   void * jresult ;
66356   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66357   Dali::Actor arg2 ;
66358   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66359   bool arg4 ;
66360   Dali::Actor *argp2 ;
66361   Dali::Actor result;
66362
66363   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66364   argp2 = (Dali::Actor *)jarg2;
66365   if (!argp2) {
66366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66367     return 0;
66368   }
66369   arg2 = *argp2;
66370   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66371   arg4 = jarg4 ? true : false;
66372   {
66373     try {
66374       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66375     } catch (std::out_of_range& e) {
66376       {
66377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66378       };
66379     } catch (std::exception& e) {
66380       {
66381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66382       };
66383     } catch (Dali::DaliException e) {
66384       {
66385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66386       };
66387     } catch (...) {
66388       {
66389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66390       };
66391     }
66392   }
66393
66394   jresult = new Dali::Actor((const Dali::Actor &)result);
66395   return jresult;
66396 }
66397
66398
66399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66400   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66401   Dali::Actor arg2 ;
66402   Dali::Actor *argp2 ;
66403
66404   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66405   argp2 = (Dali::Actor *)jarg2;
66406   if (!argp2) {
66407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66408     return ;
66409   }
66410   arg2 = *argp2;
66411   {
66412     try {
66413       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
66414     } catch (std::out_of_range& e) {
66415       {
66416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66417       };
66418     } catch (std::exception& e) {
66419       {
66420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66421       };
66422     } catch (Dali::DaliException e) {
66423       {
66424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66425       };
66426     } catch (...) {
66427       {
66428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66429       };
66430     }
66431   }
66432
66433 }
66434
66435
66436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66437   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66438   Dali::Actor arg2 ;
66439   Dali::Actor *argp2 ;
66440
66441   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66442   argp2 = (Dali::Actor *)jarg2;
66443   if (!argp2) {
66444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66445     return ;
66446   }
66447   arg2 = *argp2;
66448   {
66449     try {
66450       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
66451     } catch (std::out_of_range& e) {
66452       {
66453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66454       };
66455     } catch (std::exception& e) {
66456       {
66457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66458       };
66459     } catch (Dali::DaliException e) {
66460       {
66461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66462       };
66463     } catch (...) {
66464       {
66465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66466       };
66467     }
66468   }
66469
66470 }
66471
66472
66473 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
66474   unsigned int jresult ;
66475   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66476   bool result;
66477
66478   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66479   {
66480     try {
66481       result = (bool)(arg1)->OnKeyboardEnter();
66482     } catch (std::out_of_range& e) {
66483       {
66484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66485       };
66486     } catch (std::exception& e) {
66487       {
66488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66489       };
66490     } catch (Dali::DaliException e) {
66491       {
66492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66493       };
66494     } catch (...) {
66495       {
66496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66497       };
66498     }
66499   }
66500
66501   jresult = result;
66502   return jresult;
66503 }
66504
66505
66506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
66507   unsigned int jresult ;
66508   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66509   bool result;
66510
66511   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66512   {
66513     try {
66514       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
66515     } catch (std::out_of_range& e) {
66516       {
66517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66518       };
66519     } catch (std::exception& e) {
66520       {
66521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66522       };
66523     } catch (Dali::DaliException e) {
66524       {
66525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66526       };
66527     } catch (...) {
66528       {
66529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66530       };
66531     }
66532   }
66533
66534   jresult = result;
66535   return jresult;
66536 }
66537
66538
66539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
66540   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66541   Dali::PinchGesture *arg2 = 0 ;
66542
66543   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66544   arg2 = (Dali::PinchGesture *)jarg2;
66545   if (!arg2) {
66546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66547     return ;
66548   }
66549   {
66550     try {
66551       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
66552     } catch (std::out_of_range& e) {
66553       {
66554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66555       };
66556     } catch (std::exception& e) {
66557       {
66558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66559       };
66560     } catch (Dali::DaliException e) {
66561       {
66562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66563       };
66564     } catch (...) {
66565       {
66566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66567       };
66568     }
66569   }
66570
66571 }
66572
66573
66574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66575   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66576   Dali::PinchGesture *arg2 = 0 ;
66577
66578   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66579   arg2 = (Dali::PinchGesture *)jarg2;
66580   if (!arg2) {
66581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66582     return ;
66583   }
66584   {
66585     try {
66586       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
66587     } catch (std::out_of_range& e) {
66588       {
66589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66590       };
66591     } catch (std::exception& e) {
66592       {
66593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66594       };
66595     } catch (Dali::DaliException e) {
66596       {
66597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66598       };
66599     } catch (...) {
66600       {
66601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66602       };
66603     }
66604   }
66605
66606 }
66607
66608
66609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
66610   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66611   Dali::PanGesture *arg2 = 0 ;
66612
66613   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66614   arg2 = (Dali::PanGesture *)jarg2;
66615   if (!arg2) {
66616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66617     return ;
66618   }
66619   {
66620     try {
66621       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
66622     } catch (std::out_of_range& e) {
66623       {
66624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66625       };
66626     } catch (std::exception& e) {
66627       {
66628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66629       };
66630     } catch (Dali::DaliException e) {
66631       {
66632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66633       };
66634     } catch (...) {
66635       {
66636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66637       };
66638     }
66639   }
66640
66641 }
66642
66643
66644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66645   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66646   Dali::PanGesture *arg2 = 0 ;
66647
66648   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66649   arg2 = (Dali::PanGesture *)jarg2;
66650   if (!arg2) {
66651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66652     return ;
66653   }
66654   {
66655     try {
66656       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
66657     } catch (std::out_of_range& e) {
66658       {
66659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66660       };
66661     } catch (std::exception& e) {
66662       {
66663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66664       };
66665     } catch (Dali::DaliException e) {
66666       {
66667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66668       };
66669     } catch (...) {
66670       {
66671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66672       };
66673     }
66674   }
66675
66676 }
66677
66678
66679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
66680   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66681   Dali::TapGesture *arg2 = 0 ;
66682
66683   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66684   arg2 = (Dali::TapGesture *)jarg2;
66685   if (!arg2) {
66686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66687     return ;
66688   }
66689   {
66690     try {
66691       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
66692     } catch (std::out_of_range& e) {
66693       {
66694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66695       };
66696     } catch (std::exception& e) {
66697       {
66698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66699       };
66700     } catch (Dali::DaliException e) {
66701       {
66702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66703       };
66704     } catch (...) {
66705       {
66706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66707       };
66708     }
66709   }
66710
66711 }
66712
66713
66714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66715   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66716   Dali::TapGesture *arg2 = 0 ;
66717
66718   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66719   arg2 = (Dali::TapGesture *)jarg2;
66720   if (!arg2) {
66721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66722     return ;
66723   }
66724   {
66725     try {
66726       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
66727     } catch (std::out_of_range& e) {
66728       {
66729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66730       };
66731     } catch (std::exception& e) {
66732       {
66733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66734       };
66735     } catch (Dali::DaliException e) {
66736       {
66737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66738       };
66739     } catch (...) {
66740       {
66741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66742       };
66743     }
66744   }
66745
66746 }
66747
66748
66749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
66750   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66751   Dali::LongPressGesture *arg2 = 0 ;
66752
66753   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66754   arg2 = (Dali::LongPressGesture *)jarg2;
66755   if (!arg2) {
66756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66757     return ;
66758   }
66759   {
66760     try {
66761       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
66762     } catch (std::out_of_range& e) {
66763       {
66764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66765       };
66766     } catch (std::exception& e) {
66767       {
66768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66769       };
66770     } catch (Dali::DaliException e) {
66771       {
66772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66773       };
66774     } catch (...) {
66775       {
66776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66777       };
66778     }
66779   }
66780
66781 }
66782
66783
66784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66785   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66786   Dali::LongPressGesture *arg2 = 0 ;
66787
66788   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66789   arg2 = (Dali::LongPressGesture *)jarg2;
66790   if (!arg2) {
66791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66792     return ;
66793   }
66794   {
66795     try {
66796       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
66797     } catch (std::out_of_range& e) {
66798       {
66799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66800       };
66801     } catch (std::exception& e) {
66802       {
66803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66804       };
66805     } catch (Dali::DaliException e) {
66806       {
66807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66808       };
66809     } catch (...) {
66810       {
66811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66812       };
66813     }
66814   }
66815
66816 }
66817
66818
66819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
66820   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66821   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66822   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66823
66824   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66825   arg2 = (Dali::SlotObserver *)jarg2;
66826   arg3 = (Dali::CallbackBase *)jarg3;
66827   {
66828     try {
66829       (arg1)->SignalConnected(arg2,arg3);
66830     } catch (std::out_of_range& e) {
66831       {
66832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66833       };
66834     } catch (std::exception& e) {
66835       {
66836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66837       };
66838     } catch (Dali::DaliException e) {
66839       {
66840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66841       };
66842     } catch (...) {
66843       {
66844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66845       };
66846     }
66847   }
66848
66849 }
66850
66851
66852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
66853   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66854   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66855   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66856
66857   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66858   arg2 = (Dali::SlotObserver *)jarg2;
66859   arg3 = (Dali::CallbackBase *)jarg3;
66860   {
66861     try {
66862       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
66863     } catch (std::out_of_range& e) {
66864       {
66865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66866       };
66867     } catch (std::exception& e) {
66868       {
66869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66870       };
66871     } catch (Dali::DaliException e) {
66872       {
66873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66874       };
66875     } catch (...) {
66876       {
66877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66878       };
66879     }
66880   }
66881
66882 }
66883
66884
66885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
66886   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66887   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66888   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66889
66890   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66891   arg2 = (Dali::SlotObserver *)jarg2;
66892   arg3 = (Dali::CallbackBase *)jarg3;
66893   {
66894     try {
66895       (arg1)->SignalDisconnected(arg2,arg3);
66896     } catch (std::out_of_range& e) {
66897       {
66898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66899       };
66900     } catch (std::exception& e) {
66901       {
66902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66903       };
66904     } catch (Dali::DaliException e) {
66905       {
66906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66907       };
66908     } catch (...) {
66909       {
66910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66911       };
66912     }
66913   }
66914
66915 }
66916
66917
66918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
66919   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66920   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66921   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66922
66923   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66924   arg2 = (Dali::SlotObserver *)jarg2;
66925   arg3 = (Dali::CallbackBase *)jarg3;
66926   {
66927     try {
66928       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
66929     } catch (std::out_of_range& e) {
66930       {
66931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66932       };
66933     } catch (std::exception& e) {
66934       {
66935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66936       };
66937     } catch (Dali::DaliException e) {
66938       {
66939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66940       };
66941     } catch (...) {
66942       {
66943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66944       };
66945     }
66946   }
66947
66948 }
66949
66950
66951 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) {
66952   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
66953   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
66954   if (director) {
66955     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);
66956   }
66957 }
66958
66959
66960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
66961   void * jresult ;
66962   Dali::Toolkit::Control *arg1 = 0 ;
66963   Dali::Toolkit::Internal::Control *result = 0 ;
66964
66965   arg1 = (Dali::Toolkit::Control *)jarg1;
66966   if (!arg1) {
66967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
66968     return 0;
66969   }
66970   {
66971     try {
66972       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
66973     } catch (std::out_of_range& e) {
66974       {
66975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66976       };
66977     } catch (std::exception& e) {
66978       {
66979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66980       };
66981     } catch (Dali::DaliException e) {
66982       {
66983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66984       };
66985     } catch (...) {
66986       {
66987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66988       };
66989     }
66990   }
66991
66992   jresult = (void *)result;
66993   return jresult;
66994 }
66995
66996
66997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
66998   int jresult ;
66999   int result;
67000
67001   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
67002   jresult = (int)result;
67003   return jresult;
67004 }
67005
67006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
67007   int jresult ;
67008   int result;
67009
67010   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
67011   jresult = (int)result;
67012   return jresult;
67013 }
67014
67015
67016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
67017   int jresult ;
67018   int result;
67019
67020   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
67021   jresult = (int)result;
67022   return jresult;
67023 }
67024
67025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
67026   int jresult ;
67027   int result;
67028
67029   result = (int)Dali::Toolkit::Control::Property::MARGIN;
67030   jresult = (int)result;
67031   return jresult;
67032 }
67033
67034
67035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
67036   int jresult ;
67037   int result;
67038
67039   result = (int)Dali::Toolkit::Control::Property::PADDING;
67040   jresult = (int)result;
67041   return jresult;
67042 }
67043
67044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() {
67045   int jresult ;
67046   int result;
67047
67048   result = (int)Dali::Toolkit::DevelControl::Property::SHADOW;
67049   jresult = (int)result;
67050   return jresult;
67051 }
67052
67053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
67054   void * jresult ;
67055   Dali::Toolkit::Control::Property *result = 0 ;
67056
67057   {
67058     try {
67059       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
67060     } catch (std::out_of_range& e) {
67061       {
67062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67063       };
67064     } catch (std::exception& e) {
67065       {
67066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67067       };
67068     } catch (Dali::DaliException e) {
67069       {
67070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67071       };
67072     } catch (...) {
67073       {
67074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67075       };
67076     }
67077   }
67078
67079   jresult = (void *)result;
67080   return jresult;
67081 }
67082
67083
67084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
67085   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
67086
67087   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
67088   {
67089     try {
67090       delete arg1;
67091     } catch (std::out_of_range& e) {
67092       {
67093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67094       };
67095     } catch (std::exception& e) {
67096       {
67097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67098       };
67099     } catch (Dali::DaliException e) {
67100       {
67101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67102       };
67103     } catch (...) {
67104       {
67105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67106       };
67107     }
67108   }
67109
67110 }
67111
67112
67113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
67114   void * jresult ;
67115   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
67116
67117   {
67118     try {
67119       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
67120     } catch (std::out_of_range& e) {
67121       {
67122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67123       };
67124     } catch (std::exception& e) {
67125       {
67126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67127       };
67128     } catch (Dali::DaliException e) {
67129       {
67130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67131       };
67132     } catch (...) {
67133       {
67134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67135       };
67136     }
67137   }
67138
67139   jresult = (void *)result;
67140   return jresult;
67141 }
67142
67143
67144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
67145   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
67146
67147   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
67148   {
67149     try {
67150       delete arg1;
67151     } catch (std::out_of_range& e) {
67152       {
67153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67154       };
67155     } catch (std::exception& e) {
67156       {
67157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67158       };
67159     } catch (Dali::DaliException e) {
67160       {
67161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67162       };
67163     } catch (...) {
67164       {
67165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67166       };
67167     }
67168   }
67169
67170 }
67171
67172
67173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
67174   void * jresult ;
67175   Dali::Toolkit::Control result;
67176
67177   {
67178     try {
67179       result = Dali::Toolkit::Control::New();
67180     } catch (std::out_of_range& e) {
67181       {
67182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67183       };
67184     } catch (std::exception& e) {
67185       {
67186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67187       };
67188     } catch (Dali::DaliException e) {
67189       {
67190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67191       };
67192     } catch (...) {
67193       {
67194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67195       };
67196     }
67197   }
67198
67199   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67200   return jresult;
67201 }
67202
67203
67204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
67205   void * jresult ;
67206   Dali::Toolkit::Control *result = 0 ;
67207
67208   {
67209     try {
67210       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
67211     } catch (std::out_of_range& e) {
67212       {
67213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67214       };
67215     } catch (std::exception& e) {
67216       {
67217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67218       };
67219     } catch (Dali::DaliException e) {
67220       {
67221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67222       };
67223     } catch (...) {
67224       {
67225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67226       };
67227     }
67228   }
67229
67230   jresult = (void *)result;
67231   return jresult;
67232 }
67233
67234
67235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
67236   void * jresult ;
67237   Dali::Toolkit::Control *arg1 = 0 ;
67238   Dali::Toolkit::Control *result = 0 ;
67239
67240   arg1 = (Dali::Toolkit::Control *)jarg1;
67241   if (!arg1) {
67242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67243     return 0;
67244   }
67245   {
67246     try {
67247       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
67248     } catch (std::out_of_range& e) {
67249       {
67250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67251       };
67252     } catch (std::exception& e) {
67253       {
67254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67255       };
67256     } catch (Dali::DaliException e) {
67257       {
67258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67259       };
67260     } catch (...) {
67261       {
67262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67263       };
67264     }
67265   }
67266
67267   jresult = (void *)result;
67268   return jresult;
67269 }
67270
67271
67272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
67273   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67274
67275   arg1 = (Dali::Toolkit::Control *)jarg1;
67276   {
67277     try {
67278       delete arg1;
67279     } catch (std::out_of_range& e) {
67280       {
67281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67282       };
67283     } catch (std::exception& e) {
67284       {
67285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67286       };
67287     } catch (Dali::DaliException e) {
67288       {
67289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67290       };
67291     } catch (...) {
67292       {
67293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67294       };
67295     }
67296   }
67297
67298 }
67299
67300
67301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67302   void * jresult ;
67303   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67304   Dali::Toolkit::Control *arg2 = 0 ;
67305   Dali::Toolkit::Control *result = 0 ;
67306
67307   arg1 = (Dali::Toolkit::Control *)jarg1;
67308   arg2 = (Dali::Toolkit::Control *)jarg2;
67309   if (!arg2) {
67310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67311     return 0;
67312   }
67313   {
67314     try {
67315       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67316     } catch (std::out_of_range& e) {
67317       {
67318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67319       };
67320     } catch (std::exception& e) {
67321       {
67322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67323       };
67324     } catch (Dali::DaliException e) {
67325       {
67326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67327       };
67328     } catch (...) {
67329       {
67330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67331       };
67332     }
67333   }
67334
67335   jresult = (void *)result;
67336   return jresult;
67337 }
67338
67339
67340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67341   void * jresult ;
67342   Dali::BaseHandle arg1 ;
67343   Dali::BaseHandle *argp1 ;
67344   Dali::Toolkit::Control result;
67345
67346   argp1 = (Dali::BaseHandle *)jarg1;
67347   if (!argp1) {
67348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67349     return 0;
67350   }
67351   arg1 = *argp1;
67352   {
67353     try {
67354       result = Dali::Toolkit::Control::DownCast(arg1);
67355     } catch (std::out_of_range& e) {
67356       {
67357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67358       };
67359     } catch (std::exception& e) {
67360       {
67361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67362       };
67363     } catch (Dali::DaliException e) {
67364       {
67365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67366       };
67367     } catch (...) {
67368       {
67369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67370       };
67371     }
67372   }
67373
67374   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67375   return jresult;
67376 }
67377
67378
67379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67380   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67381
67382   arg1 = (Dali::Toolkit::Control *)jarg1;
67383   {
67384     try {
67385       (arg1)->SetKeyInputFocus();
67386     } catch (std::out_of_range& e) {
67387       {
67388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67389       };
67390     } catch (std::exception& e) {
67391       {
67392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67393       };
67394     } catch (Dali::DaliException e) {
67395       {
67396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67397       };
67398     } catch (...) {
67399       {
67400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67401       };
67402     }
67403   }
67404
67405 }
67406
67407
67408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
67409   unsigned int jresult ;
67410   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67411   bool result;
67412
67413   arg1 = (Dali::Toolkit::Control *)jarg1;
67414   {
67415     try {
67416       result = (bool)(arg1)->HasKeyInputFocus();
67417     } catch (std::out_of_range& e) {
67418       {
67419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67420       };
67421     } catch (std::exception& e) {
67422       {
67423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67424       };
67425     } catch (Dali::DaliException e) {
67426       {
67427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67428       };
67429     } catch (...) {
67430       {
67431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67432       };
67433     }
67434   }
67435
67436   jresult = result;
67437   return jresult;
67438 }
67439
67440
67441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
67442   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67443
67444   arg1 = (Dali::Toolkit::Control *)jarg1;
67445   {
67446     try {
67447       (arg1)->ClearKeyInputFocus();
67448     } catch (std::out_of_range& e) {
67449       {
67450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67451       };
67452     } catch (std::exception& e) {
67453       {
67454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67455       };
67456     } catch (Dali::DaliException e) {
67457       {
67458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67459       };
67460     } catch (...) {
67461       {
67462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67463       };
67464     }
67465   }
67466
67467 }
67468
67469
67470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
67471   void * jresult ;
67472   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67473   Dali::PinchGestureDetector result;
67474
67475   arg1 = (Dali::Toolkit::Control *)jarg1;
67476   {
67477     try {
67478       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
67479     } catch (std::out_of_range& e) {
67480       {
67481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67482       };
67483     } catch (std::exception& e) {
67484       {
67485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67486       };
67487     } catch (Dali::DaliException e) {
67488       {
67489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67490       };
67491     } catch (...) {
67492       {
67493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67494       };
67495     }
67496   }
67497
67498   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
67499   return jresult;
67500 }
67501
67502
67503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
67504   void * jresult ;
67505   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67506   Dali::PanGestureDetector result;
67507
67508   arg1 = (Dali::Toolkit::Control *)jarg1;
67509   {
67510     try {
67511       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
67512     } catch (std::out_of_range& e) {
67513       {
67514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67515       };
67516     } catch (std::exception& e) {
67517       {
67518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67519       };
67520     } catch (Dali::DaliException e) {
67521       {
67522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67523       };
67524     } catch (...) {
67525       {
67526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67527       };
67528     }
67529   }
67530
67531   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
67532   return jresult;
67533 }
67534
67535
67536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
67537   void * jresult ;
67538   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67539   Dali::TapGestureDetector result;
67540
67541   arg1 = (Dali::Toolkit::Control *)jarg1;
67542   {
67543     try {
67544       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
67545     } catch (std::out_of_range& e) {
67546       {
67547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67548       };
67549     } catch (std::exception& e) {
67550       {
67551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67552       };
67553     } catch (Dali::DaliException e) {
67554       {
67555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67556       };
67557     } catch (...) {
67558       {
67559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67560       };
67561     }
67562   }
67563
67564   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
67565   return jresult;
67566 }
67567
67568
67569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
67570   void * jresult ;
67571   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67572   Dali::LongPressGestureDetector result;
67573
67574   arg1 = (Dali::Toolkit::Control *)jarg1;
67575   {
67576     try {
67577       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
67578     } catch (std::out_of_range& e) {
67579       {
67580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67581       };
67582     } catch (std::exception& e) {
67583       {
67584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67585       };
67586     } catch (Dali::DaliException e) {
67587       {
67588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67589       };
67590     } catch (...) {
67591       {
67592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67593       };
67594     }
67595   }
67596
67597   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
67598   return jresult;
67599 }
67600
67601
67602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
67603   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67604   std::string *arg2 = 0 ;
67605
67606   arg1 = (Dali::Toolkit::Control *)jarg1;
67607   if (!jarg2) {
67608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67609     return ;
67610   }
67611   std::string arg2_str(jarg2);
67612   arg2 = &arg2_str;
67613   {
67614     try {
67615       (arg1)->SetStyleName((std::string const &)*arg2);
67616     } catch (std::out_of_range& e) {
67617       {
67618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67619       };
67620     } catch (std::exception& e) {
67621       {
67622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67623       };
67624     } catch (Dali::DaliException e) {
67625       {
67626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67627       };
67628     } catch (...) {
67629       {
67630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67631       };
67632     }
67633   }
67634
67635
67636   //argout typemap for const std::string&
67637
67638 }
67639
67640
67641 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
67642   char * jresult ;
67643   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67644   std::string *result = 0 ;
67645
67646   arg1 = (Dali::Toolkit::Control *)jarg1;
67647   {
67648     try {
67649       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
67650     } catch (std::out_of_range& e) {
67651       {
67652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67653       };
67654     } catch (std::exception& e) {
67655       {
67656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67657       };
67658     } catch (Dali::DaliException e) {
67659       {
67660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67661       };
67662     } catch (...) {
67663       {
67664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67665       };
67666     }
67667   }
67668
67669   jresult = SWIG_csharp_string_callback(result->c_str());
67670   return jresult;
67671 }
67672
67673
67674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
67675   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67676   Dali::Vector4 *arg2 = 0 ;
67677
67678   arg1 = (Dali::Toolkit::Control *)jarg1;
67679   arg2 = (Dali::Vector4 *)jarg2;
67680   if (!arg2) {
67681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
67682     return ;
67683   }
67684   {
67685     try {
67686       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
67687     } catch (std::out_of_range& e) {
67688       {
67689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67690       };
67691     } catch (std::exception& e) {
67692       {
67693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67694       };
67695     } catch (Dali::DaliException e) {
67696       {
67697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67698       };
67699     } catch (...) {
67700       {
67701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67702       };
67703     }
67704   }
67705
67706 }
67707
67708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
67709   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67710
67711   arg1 = (Dali::Toolkit::Control *)jarg1;
67712   {
67713     try {
67714       (arg1)->ClearBackground();
67715     } catch (std::out_of_range& e) {
67716       {
67717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67718       };
67719     } catch (std::exception& e) {
67720       {
67721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67722       };
67723     } catch (Dali::DaliException e) {
67724       {
67725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67726       };
67727     } catch (...) {
67728       {
67729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67730       };
67731     }
67732   }
67733
67734 }
67735
67736
67737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
67738   void * jresult ;
67739   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67740   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
67741
67742   arg1 = (Dali::Toolkit::Control *)jarg1;
67743   {
67744     try {
67745       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
67746     } catch (std::out_of_range& e) {
67747       {
67748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67749       };
67750     } catch (std::exception& e) {
67751       {
67752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67753       };
67754     } catch (Dali::DaliException e) {
67755       {
67756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67757       };
67758     } catch (...) {
67759       {
67760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67761       };
67762     }
67763   }
67764
67765   jresult = (void *)result;
67766   return jresult;
67767 }
67768
67769
67770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
67771   void * jresult ;
67772   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67773   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
67774
67775   arg1 = (Dali::Toolkit::Control *)jarg1;
67776   {
67777     try {
67778       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
67779     } catch (std::out_of_range& e) {
67780       {
67781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67782       };
67783     } catch (std::exception& e) {
67784       {
67785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67786       };
67787     } catch (Dali::DaliException e) {
67788       {
67789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67790       };
67791     } catch (...) {
67792       {
67793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67794       };
67795     }
67796   }
67797
67798   jresult = (void *)result;
67799   return jresult;
67800 }
67801
67802
67803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
67804   void * jresult ;
67805   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67806   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
67807
67808   arg1 = (Dali::Toolkit::Control *)jarg1;
67809   {
67810     try {
67811       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
67812     } catch (std::out_of_range& e) {
67813       {
67814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67815       };
67816     } catch (std::exception& e) {
67817       {
67818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67819       };
67820     } catch (Dali::DaliException e) {
67821       {
67822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67823       };
67824     } catch (...) {
67825       {
67826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67827       };
67828     }
67829   }
67830
67831   jresult = (void *)result;
67832   return jresult;
67833 }
67834
67835
67836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
67837   void * jresult ;
67838   Dali::Toolkit::Internal::Control *arg1 = 0 ;
67839   Dali::Toolkit::Control *result = 0 ;
67840
67841   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67842   if (!arg1) {
67843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
67844     return 0;
67845   }
67846   {
67847     try {
67848       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
67849     } catch (std::out_of_range& e) {
67850       {
67851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67852       };
67853     } catch (std::exception& e) {
67854       {
67855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67856       };
67857     } catch (Dali::DaliException e) {
67858       {
67859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67860       };
67861     } catch (...) {
67862       {
67863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67864       };
67865     }
67866   }
67867
67868   jresult = (void *)result;
67869   return jresult;
67870 }
67871
67872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
67873 {
67874   int jresult;
67875   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67876   arg1 = (Dali::Toolkit::Control *)jarg1;
67877
67878   if (!arg1) {
67879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67880     return 0;
67881   }
67882
67883   Dali::Property::Index arg2 = 0 ;
67884   arg2 = (Dali::Property::Index)jarg2;
67885
67886   Toolkit::Visual::ResourceStatus result;
67887   {
67888     try {
67889       result = arg1->GetVisualResourceStatus(arg2);
67890     } catch (std::out_of_range& e) {
67891       {
67892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67893       };
67894     } catch (std::exception& e) {
67895       {
67896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67897       };
67898     } catch (...) {
67899       {
67900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67901       };
67902     }
67903   }
67904   jresult = (int)(result);
67905   return jresult;
67906 }
67907
67908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
67909 {
67910   void * jresult;
67911   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67912   arg1 = (Dali::Toolkit::Control *)jarg1;
67913
67914   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
67915
67916   Dali::Toolkit::TransitionData *arg2 = 0 ;
67917   Dali::Animation result;
67918
67919   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
67920   if (!arg2) {
67921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
67922     return 0;
67923   }
67924   {
67925     try {
67926       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
67927     } catch (std::out_of_range& e) {
67928       {
67929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67930       };
67931     } catch (std::exception& e) {
67932       {
67933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67934       };
67935     } catch (Dali::DaliException e) {
67936       {
67937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67938       };
67939     } catch (...) {
67940       {
67941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67942       };
67943     }
67944   }
67945
67946   jresult = new Dali::Animation((const Dali::Animation &)result);
67947   return jresult;
67948 }
67949
67950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
67951 {
67952   Dali::Toolkit::Control arg1;
67953   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
67954
67955   if (!argp1) {
67956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67957   }
67958   arg1 = *argp1;
67959
67960   Dali::Property::Index arg2 = 0 ;
67961   arg2 = (Dali::Property::Index)jarg2;
67962
67963   Dali::Property::Index arg3 = 0 ;
67964   arg3 = (Dali::Property::Index)jarg3;
67965
67966   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
67967
67968   {
67969     try {
67970       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
67971     } catch (std::out_of_range& e) {
67972       {
67973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67974       };
67975     } catch (std::exception& e) {
67976       {
67977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67978       };
67979     } catch (...) {
67980       {
67981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67982       };
67983     }
67984   }
67985
67986
67987 }
67988
67989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
67990   void * jresult ;
67991   Dali::Toolkit::Control *arg1 = 0 ;
67992   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
67993
67994   arg1 = (Dali::Toolkit::Control *)jarg1;
67995   if (!arg1) {
67996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67997     return 0;
67998   }
67999   {
68000     try {
68001       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
68002     } catch (std::out_of_range& e) {
68003       {
68004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68005       };
68006     } catch (std::exception& e) {
68007       {
68008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68009       };
68010     } catch (Dali::DaliException e) {
68011       {
68012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68013       };
68014     } catch (...) {
68015       {
68016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68017       };
68018     }
68019   }
68020
68021   jresult = (void *)result;
68022   return jresult;
68023 }
68024
68025
68026 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
68027   unsigned int jresult ;
68028   Dali::Toolkit::Control *arg1 = 0 ;
68029   bool result;
68030
68031   arg1 = (Dali::Toolkit::Control *)jarg1;
68032   if (!arg1) {
68033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68034     return 0;
68035   }
68036   {
68037     try {
68038       result = (bool)arg1->IsResourceReady();
68039     } catch (std::out_of_range& e) {
68040       {
68041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68042       };
68043     } catch (std::exception& e) {
68044       {
68045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68046       };
68047     } catch (Dali::DaliException e) {
68048       {
68049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68050       };
68051     } catch (...) {
68052       {
68053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68054       };
68055     }
68056   }
68057
68058   jresult = result;
68059   return jresult;
68060 }
68061
68062
68063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
68064   void * jresult ;
68065   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
68066
68067   {
68068     try {
68069       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
68070     } catch (std::out_of_range& e) {
68071       {
68072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68073       };
68074     } catch (std::exception& e) {
68075       {
68076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68077       };
68078     } catch (Dali::DaliException e) {
68079       {
68080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68081       };
68082     } catch (...) {
68083       {
68084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68085       };
68086     }
68087   }
68088
68089   jresult = (void *)result;
68090   return jresult;
68091 }
68092
68093
68094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68095   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68096
68097   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68098   {
68099     try {
68100       delete arg1;
68101     } catch (std::out_of_range& e) {
68102       {
68103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68104       };
68105     } catch (std::exception& e) {
68106       {
68107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68108       };
68109     } catch (Dali::DaliException e) {
68110       {
68111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68112       };
68113     } catch (...) {
68114       {
68115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68116       };
68117     }
68118   }
68119
68120 }
68121
68122
68123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68124   void * jresult ;
68125   Dali::Toolkit::KeyInputFocusManager result;
68126
68127   {
68128     try {
68129       result = Dali::Toolkit::KeyInputFocusManager::Get();
68130     } catch (std::out_of_range& e) {
68131       {
68132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68133       };
68134     } catch (std::exception& e) {
68135       {
68136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68137       };
68138     } catch (Dali::DaliException e) {
68139       {
68140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68141       };
68142     } catch (...) {
68143       {
68144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68145       };
68146     }
68147   }
68148
68149   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68150   return jresult;
68151 }
68152
68153
68154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68155   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68156   Dali::Toolkit::Control arg2 ;
68157   Dali::Toolkit::Control *argp2 ;
68158
68159   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68160   argp2 = (Dali::Toolkit::Control *)jarg2;
68161   if (!argp2) {
68162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68163     return ;
68164   }
68165   arg2 = *argp2;
68166   {
68167     try {
68168       (arg1)->SetFocus(arg2);
68169     } catch (std::out_of_range& e) {
68170       {
68171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68172       };
68173     } catch (std::exception& e) {
68174       {
68175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68176       };
68177     } catch (Dali::DaliException e) {
68178       {
68179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68180       };
68181     } catch (...) {
68182       {
68183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68184       };
68185     }
68186   }
68187
68188 }
68189
68190
68191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68192   void * jresult ;
68193   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68194   Dali::Toolkit::Control result;
68195
68196   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68197   {
68198     try {
68199       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68200     } catch (std::out_of_range& e) {
68201       {
68202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68203       };
68204     } catch (std::exception& e) {
68205       {
68206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68207       };
68208     } catch (Dali::DaliException e) {
68209       {
68210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68211       };
68212     } catch (...) {
68213       {
68214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68215       };
68216     }
68217   }
68218
68219   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68220   return jresult;
68221 }
68222
68223
68224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
68225   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68226   Dali::Toolkit::Control arg2 ;
68227   Dali::Toolkit::Control *argp2 ;
68228
68229   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68230   argp2 = (Dali::Toolkit::Control *)jarg2;
68231   if (!argp2) {
68232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68233     return ;
68234   }
68235   arg2 = *argp2;
68236   {
68237     try {
68238       (arg1)->RemoveFocus(arg2);
68239     } catch (std::out_of_range& e) {
68240       {
68241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68242       };
68243     } catch (std::exception& e) {
68244       {
68245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68246       };
68247     } catch (Dali::DaliException e) {
68248       {
68249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68250       };
68251     } catch (...) {
68252       {
68253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68254       };
68255     }
68256   }
68257
68258 }
68259
68260
68261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
68262   void * jresult ;
68263   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68264   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
68265
68266   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68267   {
68268     try {
68269       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
68270     } catch (std::out_of_range& e) {
68271       {
68272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68273       };
68274     } catch (std::exception& e) {
68275       {
68276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68277       };
68278     } catch (Dali::DaliException e) {
68279       {
68280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68281       };
68282     } catch (...) {
68283       {
68284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68285       };
68286     }
68287   }
68288
68289   jresult = (void *)result;
68290   return jresult;
68291 }
68292
68293
68294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
68295   void * jresult ;
68296   Dali::Toolkit::Alignment::Padding *result = 0 ;
68297
68298   {
68299     try {
68300       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
68301     } catch (std::out_of_range& e) {
68302       {
68303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68304       };
68305     } catch (std::exception& e) {
68306       {
68307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68308       };
68309     } catch (Dali::DaliException e) {
68310       {
68311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68312       };
68313     } catch (...) {
68314       {
68315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68316       };
68317     }
68318   }
68319
68320   jresult = (void *)result;
68321   return jresult;
68322 }
68323
68324
68325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
68326   void * jresult ;
68327   float arg1 ;
68328   float arg2 ;
68329   float arg3 ;
68330   float arg4 ;
68331   Dali::Toolkit::Alignment::Padding *result = 0 ;
68332
68333   arg1 = (float)jarg1;
68334   arg2 = (float)jarg2;
68335   arg3 = (float)jarg3;
68336   arg4 = (float)jarg4;
68337   {
68338     try {
68339       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
68340     } catch (std::out_of_range& e) {
68341       {
68342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68343       };
68344     } catch (std::exception& e) {
68345       {
68346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68347       };
68348     } catch (Dali::DaliException e) {
68349       {
68350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68351       };
68352     } catch (...) {
68353       {
68354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68355       };
68356     }
68357   }
68358
68359   jresult = (void *)result;
68360   return jresult;
68361 }
68362
68363
68364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
68365   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68366   float arg2 ;
68367
68368   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68369   arg2 = (float)jarg2;
68370   if (arg1) (arg1)->left = arg2;
68371 }
68372
68373
68374 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
68375   float jresult ;
68376   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68377   float result;
68378
68379   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68380   result = (float) ((arg1)->left);
68381   jresult = result;
68382   return jresult;
68383 }
68384
68385
68386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
68387   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68388   float arg2 ;
68389
68390   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68391   arg2 = (float)jarg2;
68392   if (arg1) (arg1)->right = arg2;
68393 }
68394
68395
68396 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
68397   float jresult ;
68398   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68399   float result;
68400
68401   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68402   result = (float) ((arg1)->right);
68403   jresult = result;
68404   return jresult;
68405 }
68406
68407
68408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
68409   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68410   float arg2 ;
68411
68412   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68413   arg2 = (float)jarg2;
68414   if (arg1) (arg1)->top = arg2;
68415 }
68416
68417
68418 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
68419   float jresult ;
68420   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68421   float result;
68422
68423   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68424   result = (float) ((arg1)->top);
68425   jresult = result;
68426   return jresult;
68427 }
68428
68429
68430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
68431   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68432   float arg2 ;
68433
68434   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68435   arg2 = (float)jarg2;
68436   if (arg1) (arg1)->bottom = arg2;
68437 }
68438
68439
68440 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
68441   float jresult ;
68442   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68443   float result;
68444
68445   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68446   result = (float) ((arg1)->bottom);
68447   jresult = result;
68448   return jresult;
68449 }
68450
68451
68452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
68453   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68454
68455   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68456   {
68457     try {
68458       delete arg1;
68459     } catch (std::out_of_range& e) {
68460       {
68461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68462       };
68463     } catch (std::exception& e) {
68464       {
68465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68466       };
68467     } catch (Dali::DaliException e) {
68468       {
68469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68470       };
68471     } catch (...) {
68472       {
68473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68474       };
68475     }
68476   }
68477
68478 }
68479
68480
68481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
68482   void * jresult ;
68483   Dali::Toolkit::Alignment *result = 0 ;
68484
68485   {
68486     try {
68487       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
68488     } catch (std::out_of_range& e) {
68489       {
68490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68491       };
68492     } catch (std::exception& e) {
68493       {
68494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68495       };
68496     } catch (Dali::DaliException e) {
68497       {
68498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68499       };
68500     } catch (...) {
68501       {
68502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68503       };
68504     }
68505   }
68506
68507   jresult = (void *)result;
68508   return jresult;
68509 }
68510
68511
68512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
68513   void * jresult ;
68514   Dali::Toolkit::Alignment::Type arg1 ;
68515   Dali::Toolkit::Alignment::Type arg2 ;
68516   Dali::Toolkit::Alignment result;
68517
68518   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68519   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68520   {
68521     try {
68522       result = Dali::Toolkit::Alignment::New(arg1,arg2);
68523     } catch (std::out_of_range& e) {
68524       {
68525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68526       };
68527     } catch (std::exception& e) {
68528       {
68529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68530       };
68531     } catch (Dali::DaliException e) {
68532       {
68533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68534       };
68535     } catch (...) {
68536       {
68537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68538       };
68539     }
68540   }
68541
68542   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68543   return jresult;
68544 }
68545
68546
68547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
68548   void * jresult ;
68549   Dali::Toolkit::Alignment::Type arg1 ;
68550   Dali::Toolkit::Alignment result;
68551
68552   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68553   {
68554     try {
68555       result = Dali::Toolkit::Alignment::New(arg1);
68556     } catch (std::out_of_range& e) {
68557       {
68558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68559       };
68560     } catch (std::exception& e) {
68561       {
68562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68563       };
68564     } catch (Dali::DaliException e) {
68565       {
68566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68567       };
68568     } catch (...) {
68569       {
68570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68571       };
68572     }
68573   }
68574
68575   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68576   return jresult;
68577 }
68578
68579
68580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
68581   void * jresult ;
68582   Dali::Toolkit::Alignment result;
68583
68584   {
68585     try {
68586       result = Dali::Toolkit::Alignment::New();
68587     } catch (std::out_of_range& e) {
68588       {
68589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68590       };
68591     } catch (std::exception& e) {
68592       {
68593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68594       };
68595     } catch (Dali::DaliException e) {
68596       {
68597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68598       };
68599     } catch (...) {
68600       {
68601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68602       };
68603     }
68604   }
68605
68606   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68607   return jresult;
68608 }
68609
68610
68611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
68612   void * jresult ;
68613   Dali::Toolkit::Alignment *arg1 = 0 ;
68614   Dali::Toolkit::Alignment *result = 0 ;
68615
68616   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68617   if (!arg1) {
68618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68619     return 0;
68620   }
68621   {
68622     try {
68623       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
68624     } catch (std::out_of_range& e) {
68625       {
68626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68627       };
68628     } catch (std::exception& e) {
68629       {
68630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68631       };
68632     } catch (Dali::DaliException e) {
68633       {
68634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68635       };
68636     } catch (...) {
68637       {
68638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68639       };
68640     }
68641   }
68642
68643   jresult = (void *)result;
68644   return jresult;
68645 }
68646
68647
68648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
68649   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68650
68651   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68652   {
68653     try {
68654       delete arg1;
68655     } catch (std::out_of_range& e) {
68656       {
68657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68658       };
68659     } catch (std::exception& e) {
68660       {
68661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68662       };
68663     } catch (Dali::DaliException e) {
68664       {
68665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68666       };
68667     } catch (...) {
68668       {
68669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68670       };
68671     }
68672   }
68673
68674 }
68675
68676
68677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
68678   void * jresult ;
68679   Dali::BaseHandle arg1 ;
68680   Dali::BaseHandle *argp1 ;
68681   Dali::Toolkit::Alignment result;
68682
68683   argp1 = (Dali::BaseHandle *)jarg1;
68684   if (!argp1) {
68685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68686     return 0;
68687   }
68688   arg1 = *argp1;
68689   {
68690     try {
68691       result = Dali::Toolkit::Alignment::DownCast(arg1);
68692     } catch (std::out_of_range& e) {
68693       {
68694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68695       };
68696     } catch (std::exception& e) {
68697       {
68698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68699       };
68700     } catch (Dali::DaliException e) {
68701       {
68702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68703       };
68704     } catch (...) {
68705       {
68706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68707       };
68708     }
68709   }
68710
68711   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68712   return jresult;
68713 }
68714
68715
68716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
68717   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68718   Dali::Toolkit::Alignment::Type arg2 ;
68719
68720   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68721   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68722   {
68723     try {
68724       (arg1)->SetAlignmentType(arg2);
68725     } catch (std::out_of_range& e) {
68726       {
68727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68728       };
68729     } catch (std::exception& e) {
68730       {
68731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68732       };
68733     } catch (Dali::DaliException e) {
68734       {
68735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68736       };
68737     } catch (...) {
68738       {
68739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68740       };
68741     }
68742   }
68743
68744 }
68745
68746
68747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
68748   int jresult ;
68749   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68750   Dali::Toolkit::Alignment::Type result;
68751
68752   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68753   {
68754     try {
68755       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
68756     } catch (std::out_of_range& e) {
68757       {
68758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68759       };
68760     } catch (std::exception& e) {
68761       {
68762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68763       };
68764     } catch (Dali::DaliException e) {
68765       {
68766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68767       };
68768     } catch (...) {
68769       {
68770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68771       };
68772     }
68773   }
68774
68775   jresult = (int)result;
68776   return jresult;
68777 }
68778
68779
68780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
68781   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68782   Dali::Toolkit::Alignment::Scaling arg2 ;
68783
68784   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68785   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
68786   {
68787     try {
68788       (arg1)->SetScaling(arg2);
68789     } catch (std::out_of_range& e) {
68790       {
68791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68792       };
68793     } catch (std::exception& e) {
68794       {
68795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68796       };
68797     } catch (Dali::DaliException e) {
68798       {
68799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68800       };
68801     } catch (...) {
68802       {
68803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68804       };
68805     }
68806   }
68807
68808 }
68809
68810
68811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
68812   int jresult ;
68813   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68814   Dali::Toolkit::Alignment::Scaling result;
68815
68816   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68817   {
68818     try {
68819       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
68820     } catch (std::out_of_range& e) {
68821       {
68822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68823       };
68824     } catch (std::exception& e) {
68825       {
68826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68827       };
68828     } catch (Dali::DaliException e) {
68829       {
68830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68831       };
68832     } catch (...) {
68833       {
68834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68835       };
68836     }
68837   }
68838
68839   jresult = (int)result;
68840   return jresult;
68841 }
68842
68843
68844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
68845   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68846   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
68847
68848   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68849   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
68850   if (!arg2) {
68851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
68852     return ;
68853   }
68854   {
68855     try {
68856       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
68857     } catch (std::out_of_range& e) {
68858       {
68859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68860       };
68861     } catch (std::exception& e) {
68862       {
68863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68864       };
68865     } catch (Dali::DaliException e) {
68866       {
68867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68868       };
68869     } catch (...) {
68870       {
68871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68872       };
68873     }
68874   }
68875
68876 }
68877
68878
68879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
68880   void * jresult ;
68881   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68882   Dali::Toolkit::Alignment::Padding *result = 0 ;
68883
68884   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68885   {
68886     try {
68887       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
68888     } catch (std::out_of_range& e) {
68889       {
68890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68891       };
68892     } catch (std::exception& e) {
68893       {
68894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68895       };
68896     } catch (Dali::DaliException e) {
68897       {
68898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68899       };
68900     } catch (...) {
68901       {
68902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68903       };
68904     }
68905   }
68906
68907   jresult = (void *)result;
68908   return jresult;
68909 }
68910
68911
68912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
68913   void * jresult ;
68914   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68915   Dali::Toolkit::Alignment *arg2 = 0 ;
68916   Dali::Toolkit::Alignment *result = 0 ;
68917
68918   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68919   arg2 = (Dali::Toolkit::Alignment *)jarg2;
68920   if (!arg2) {
68921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68922     return 0;
68923   }
68924   {
68925     try {
68926       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
68927     } catch (std::out_of_range& e) {
68928       {
68929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68930       };
68931     } catch (std::exception& e) {
68932       {
68933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68934       };
68935     } catch (Dali::DaliException e) {
68936       {
68937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68938       };
68939     } catch (...) {
68940       {
68941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68942       };
68943     }
68944   }
68945
68946   jresult = (void *)result;
68947   return jresult;
68948 }
68949
68950
68951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
68952   int jresult ;
68953   int result;
68954
68955   result = (int)Dali::Toolkit::Button::Property::DISABLED;
68956   jresult = (int)result;
68957   return jresult;
68958 }
68959
68960
68961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
68962   int jresult ;
68963   int result;
68964
68965   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
68966   jresult = (int)result;
68967   return jresult;
68968 }
68969
68970
68971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
68972   int jresult ;
68973   int result;
68974
68975   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
68976   jresult = (int)result;
68977   return jresult;
68978 }
68979
68980
68981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
68982   int jresult ;
68983   int result;
68984
68985   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
68986   jresult = (int)result;
68987   return jresult;
68988 }
68989
68990
68991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
68992   int jresult ;
68993   int result;
68994
68995   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
68996   jresult = (int)result;
68997   return jresult;
68998 }
68999
69000
69001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
69002   int jresult ;
69003   int result;
69004
69005   result = (int)Dali::Toolkit::Button::Property::SELECTED;
69006   jresult = (int)result;
69007   return jresult;
69008 }
69009
69010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
69011   int jresult ;
69012   int result;
69013
69014   result = (int)Dali::Toolkit::Button::Property::LABEL;
69015   jresult = (int)result;
69016   return jresult;
69017 }
69018
69019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
69020   void * jresult ;
69021   Dali::Toolkit::Button::Property *result = 0 ;
69022
69023   {
69024     try {
69025       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
69026     } catch (std::out_of_range& e) {
69027       {
69028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69029       };
69030     } catch (std::exception& e) {
69031       {
69032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69033       };
69034     } catch (Dali::DaliException e) {
69035       {
69036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69037       };
69038     } catch (...) {
69039       {
69040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69041       };
69042     }
69043   }
69044
69045   jresult = (void *)result;
69046   return jresult;
69047 }
69048
69049
69050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
69051   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
69052
69053   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
69054   {
69055     try {
69056       delete arg1;
69057     } catch (std::out_of_range& e) {
69058       {
69059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69060       };
69061     } catch (std::exception& e) {
69062       {
69063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69064       };
69065     } catch (Dali::DaliException e) {
69066       {
69067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69068       };
69069     } catch (...) {
69070       {
69071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69072       };
69073     }
69074   }
69075
69076 }
69077
69078
69079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69080   void * jresult ;
69081   Dali::Toolkit::Button *result = 0 ;
69082
69083   {
69084     try {
69085       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69086     } catch (std::out_of_range& e) {
69087       {
69088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69089       };
69090     } catch (std::exception& e) {
69091       {
69092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69093       };
69094     } catch (Dali::DaliException e) {
69095       {
69096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69097       };
69098     } catch (...) {
69099       {
69100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69101       };
69102     }
69103   }
69104
69105   jresult = (void *)result;
69106   return jresult;
69107 }
69108
69109
69110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69111   void * jresult ;
69112   Dali::Toolkit::Button *arg1 = 0 ;
69113   Dali::Toolkit::Button *result = 0 ;
69114
69115   arg1 = (Dali::Toolkit::Button *)jarg1;
69116   if (!arg1) {
69117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69118     return 0;
69119   }
69120   {
69121     try {
69122       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69123     } catch (std::out_of_range& e) {
69124       {
69125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69126       };
69127     } catch (std::exception& e) {
69128       {
69129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69130       };
69131     } catch (Dali::DaliException e) {
69132       {
69133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69134       };
69135     } catch (...) {
69136       {
69137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69138       };
69139     }
69140   }
69141
69142   jresult = (void *)result;
69143   return jresult;
69144 }
69145
69146
69147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69148   void * jresult ;
69149   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69150   Dali::Toolkit::Button *arg2 = 0 ;
69151   Dali::Toolkit::Button *result = 0 ;
69152
69153   arg1 = (Dali::Toolkit::Button *)jarg1;
69154   arg2 = (Dali::Toolkit::Button *)jarg2;
69155   if (!arg2) {
69156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69157     return 0;
69158   }
69159   {
69160     try {
69161       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69162     } catch (std::out_of_range& e) {
69163       {
69164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69165       };
69166     } catch (std::exception& e) {
69167       {
69168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69169       };
69170     } catch (Dali::DaliException e) {
69171       {
69172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69173       };
69174     } catch (...) {
69175       {
69176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69177       };
69178     }
69179   }
69180
69181   jresult = (void *)result;
69182   return jresult;
69183 }
69184
69185
69186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69187   void * jresult ;
69188   Dali::BaseHandle arg1 ;
69189   Dali::BaseHandle *argp1 ;
69190   Dali::Toolkit::Button result;
69191
69192   argp1 = (Dali::BaseHandle *)jarg1;
69193   if (!argp1) {
69194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69195     return 0;
69196   }
69197   arg1 = *argp1;
69198   {
69199     try {
69200       result = Dali::Toolkit::Button::DownCast(arg1);
69201     } catch (std::out_of_range& e) {
69202       {
69203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69204       };
69205     } catch (std::exception& e) {
69206       {
69207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69208       };
69209     } catch (Dali::DaliException e) {
69210       {
69211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69212       };
69213     } catch (...) {
69214       {
69215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69216       };
69217     }
69218   }
69219
69220   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
69221   return jresult;
69222 }
69223
69224
69225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
69226   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69227
69228   arg1 = (Dali::Toolkit::Button *)jarg1;
69229   {
69230     try {
69231       delete arg1;
69232     } catch (std::out_of_range& e) {
69233       {
69234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69235       };
69236     } catch (std::exception& e) {
69237       {
69238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69239       };
69240     } catch (Dali::DaliException e) {
69241       {
69242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69243       };
69244     } catch (...) {
69245       {
69246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69247       };
69248     }
69249   }
69250
69251 }
69252
69253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
69254   void * jresult ;
69255   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69256   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69257
69258   arg1 = (Dali::Toolkit::Button *)jarg1;
69259   {
69260     try {
69261       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
69262     } catch (std::out_of_range& e) {
69263       {
69264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69265       };
69266     } catch (std::exception& e) {
69267       {
69268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69269       };
69270     } catch (Dali::DaliException e) {
69271       {
69272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69273       };
69274     } catch (...) {
69275       {
69276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69277       };
69278     }
69279   }
69280
69281   jresult = (void *)result;
69282   return jresult;
69283 }
69284
69285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
69286   void * jresult ;
69287   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69288   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69289
69290   arg1 = (Dali::Toolkit::Button *)jarg1;
69291   {
69292     try {
69293       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
69294     } catch (std::out_of_range& e) {
69295       {
69296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69297       };
69298     } catch (std::exception& e) {
69299       {
69300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69301       };
69302     } catch (Dali::DaliException e) {
69303       {
69304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69305       };
69306     } catch (...) {
69307       {
69308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69309       };
69310     }
69311   }
69312
69313   jresult = (void *)result;
69314   return jresult;
69315 }
69316
69317
69318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
69319   void * jresult ;
69320   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69321   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69322
69323   arg1 = (Dali::Toolkit::Button *)jarg1;
69324   {
69325     try {
69326       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
69327     } catch (std::out_of_range& e) {
69328       {
69329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69330       };
69331     } catch (std::exception& e) {
69332       {
69333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69334       };
69335     } catch (Dali::DaliException e) {
69336       {
69337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69338       };
69339     } catch (...) {
69340       {
69341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69342       };
69343     }
69344   }
69345
69346   jresult = (void *)result;
69347   return jresult;
69348 }
69349
69350
69351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
69352   void * jresult ;
69353   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69354   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69355
69356   arg1 = (Dali::Toolkit::Button *)jarg1;
69357   {
69358     try {
69359       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
69360     } catch (std::out_of_range& e) {
69361       {
69362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69363       };
69364     } catch (std::exception& e) {
69365       {
69366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69367       };
69368     } catch (Dali::DaliException e) {
69369       {
69370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69371       };
69372     } catch (...) {
69373       {
69374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69375       };
69376     }
69377   }
69378
69379   jresult = (void *)result;
69380   return jresult;
69381 }
69382
69383
69384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
69385   void * jresult ;
69386   Dali::Toolkit::CheckBoxButton *result = 0 ;
69387
69388   {
69389     try {
69390       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
69391     } catch (std::out_of_range& e) {
69392       {
69393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69394       };
69395     } catch (std::exception& e) {
69396       {
69397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69398       };
69399     } catch (Dali::DaliException e) {
69400       {
69401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69402       };
69403     } catch (...) {
69404       {
69405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69406       };
69407     }
69408   }
69409
69410   jresult = (void *)result;
69411   return jresult;
69412 }
69413
69414
69415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
69416   void * jresult ;
69417   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
69418   Dali::Toolkit::CheckBoxButton *result = 0 ;
69419
69420   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69421   if (!arg1) {
69422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
69423     return 0;
69424   }
69425   {
69426     try {
69427       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
69428     } catch (std::out_of_range& e) {
69429       {
69430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69431       };
69432     } catch (std::exception& e) {
69433       {
69434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69435       };
69436     } catch (Dali::DaliException e) {
69437       {
69438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69439       };
69440     } catch (...) {
69441       {
69442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69443       };
69444     }
69445   }
69446
69447   jresult = (void *)result;
69448   return jresult;
69449 }
69450
69451
69452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
69453   void * jresult ;
69454   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
69455   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
69456   Dali::Toolkit::CheckBoxButton *result = 0 ;
69457
69458   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69459   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
69460   if (!arg2) {
69461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
69462     return 0;
69463   }
69464   {
69465     try {
69466       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
69467     } catch (std::out_of_range& e) {
69468       {
69469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69470       };
69471     } catch (std::exception& e) {
69472       {
69473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69474       };
69475     } catch (Dali::DaliException e) {
69476       {
69477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69478       };
69479     } catch (...) {
69480       {
69481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69482       };
69483     }
69484   }
69485
69486   jresult = (void *)result;
69487   return jresult;
69488 }
69489
69490
69491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
69492   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
69493
69494   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69495   {
69496     try {
69497       delete arg1;
69498     } catch (std::out_of_range& e) {
69499       {
69500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69501       };
69502     } catch (std::exception& e) {
69503       {
69504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69505       };
69506     } catch (Dali::DaliException e) {
69507       {
69508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69509       };
69510     } catch (...) {
69511       {
69512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69513       };
69514     }
69515   }
69516
69517 }
69518
69519
69520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
69521   void * jresult ;
69522   Dali::Toolkit::CheckBoxButton result;
69523
69524   {
69525     try {
69526       result = Dali::Toolkit::CheckBoxButton::New();
69527     } catch (std::out_of_range& e) {
69528       {
69529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69530       };
69531     } catch (std::exception& e) {
69532       {
69533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69534       };
69535     } catch (Dali::DaliException e) {
69536       {
69537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69538       };
69539     } catch (...) {
69540       {
69541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69542       };
69543     }
69544   }
69545
69546   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
69547   return jresult;
69548 }
69549
69550
69551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
69552   void * jresult ;
69553   Dali::BaseHandle arg1 ;
69554   Dali::BaseHandle *argp1 ;
69555   Dali::Toolkit::CheckBoxButton result;
69556
69557   argp1 = (Dali::BaseHandle *)jarg1;
69558   if (!argp1) {
69559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69560     return 0;
69561   }
69562   arg1 = *argp1;
69563   {
69564     try {
69565       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
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 = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
69586   return jresult;
69587 }
69588
69589
69590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
69591   int jresult ;
69592   int result;
69593
69594   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
69595   jresult = (int)result;
69596   return jresult;
69597 }
69598
69599
69600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
69601   int jresult ;
69602   int result;
69603
69604   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
69605   jresult = (int)result;
69606   return jresult;
69607 }
69608
69609
69610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
69611   int jresult ;
69612   int result;
69613
69614   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
69615   jresult = (int)result;
69616   return jresult;
69617 }
69618
69619
69620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
69621   int jresult ;
69622   int result;
69623
69624   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
69625   jresult = (int)result;
69626   return jresult;
69627 }
69628
69629
69630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
69631   int jresult ;
69632   int result;
69633
69634   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
69635   jresult = (int)result;
69636   return jresult;
69637 }
69638
69639
69640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
69641   void * jresult ;
69642   Dali::Toolkit::PushButton::Property *result = 0 ;
69643
69644   {
69645     try {
69646       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
69647     } catch (std::out_of_range& e) {
69648       {
69649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69650       };
69651     } catch (std::exception& e) {
69652       {
69653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69654       };
69655     } catch (Dali::DaliException e) {
69656       {
69657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69658       };
69659     } catch (...) {
69660       {
69661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69662       };
69663     }
69664   }
69665
69666   jresult = (void *)result;
69667   return jresult;
69668 }
69669
69670
69671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
69672   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
69673
69674   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
69675   {
69676     try {
69677       delete arg1;
69678     } catch (std::out_of_range& e) {
69679       {
69680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69681       };
69682     } catch (std::exception& e) {
69683       {
69684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69685       };
69686     } catch (Dali::DaliException e) {
69687       {
69688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69689       };
69690     } catch (...) {
69691       {
69692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69693       };
69694     }
69695   }
69696
69697 }
69698
69699
69700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
69701   void * jresult ;
69702   Dali::Toolkit::PushButton *result = 0 ;
69703
69704   {
69705     try {
69706       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
69707     } catch (std::out_of_range& e) {
69708       {
69709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69710       };
69711     } catch (std::exception& e) {
69712       {
69713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69714       };
69715     } catch (Dali::DaliException e) {
69716       {
69717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69718       };
69719     } catch (...) {
69720       {
69721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69722       };
69723     }
69724   }
69725
69726   jresult = (void *)result;
69727   return jresult;
69728 }
69729
69730
69731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
69732   void * jresult ;
69733   Dali::Toolkit::PushButton *arg1 = 0 ;
69734   Dali::Toolkit::PushButton *result = 0 ;
69735
69736   arg1 = (Dali::Toolkit::PushButton *)jarg1;
69737   if (!arg1) {
69738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
69739     return 0;
69740   }
69741   {
69742     try {
69743       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
69744     } catch (std::out_of_range& e) {
69745       {
69746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69747       };
69748     } catch (std::exception& e) {
69749       {
69750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69751       };
69752     } catch (Dali::DaliException e) {
69753       {
69754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69755       };
69756     } catch (...) {
69757       {
69758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69759       };
69760     }
69761   }
69762
69763   jresult = (void *)result;
69764   return jresult;
69765 }
69766
69767
69768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
69769   void * jresult ;
69770   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
69771   Dali::Toolkit::PushButton *arg2 = 0 ;
69772   Dali::Toolkit::PushButton *result = 0 ;
69773
69774   arg1 = (Dali::Toolkit::PushButton *)jarg1;
69775   arg2 = (Dali::Toolkit::PushButton *)jarg2;
69776   if (!arg2) {
69777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
69778     return 0;
69779   }
69780   {
69781     try {
69782       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
69783     } catch (std::out_of_range& e) {
69784       {
69785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69786       };
69787     } catch (std::exception& e) {
69788       {
69789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69790       };
69791     } catch (Dali::DaliException e) {
69792       {
69793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69794       };
69795     } catch (...) {
69796       {
69797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69798       };
69799     }
69800   }
69801
69802   jresult = (void *)result;
69803   return jresult;
69804 }
69805
69806
69807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
69808   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
69809
69810   arg1 = (Dali::Toolkit::PushButton *)jarg1;
69811   {
69812     try {
69813       delete arg1;
69814     } catch (std::out_of_range& e) {
69815       {
69816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69817       };
69818     } catch (std::exception& e) {
69819       {
69820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69821       };
69822     } catch (Dali::DaliException e) {
69823       {
69824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69825       };
69826     } catch (...) {
69827       {
69828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69829       };
69830     }
69831   }
69832
69833 }
69834
69835
69836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
69837   void * jresult ;
69838   Dali::Toolkit::PushButton result;
69839
69840   {
69841     try {
69842       result = Dali::Toolkit::PushButton::New();
69843     } catch (std::out_of_range& e) {
69844       {
69845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69846       };
69847     } catch (std::exception& e) {
69848       {
69849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69850       };
69851     } catch (Dali::DaliException e) {
69852       {
69853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69854       };
69855     } catch (...) {
69856       {
69857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69858       };
69859     }
69860   }
69861
69862   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
69863   return jresult;
69864 }
69865
69866
69867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
69868   void * jresult ;
69869   Dali::BaseHandle arg1 ;
69870   Dali::BaseHandle *argp1 ;
69871   Dali::Toolkit::PushButton result;
69872
69873   argp1 = (Dali::BaseHandle *)jarg1;
69874   if (!argp1) {
69875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69876     return 0;
69877   }
69878   arg1 = *argp1;
69879   {
69880     try {
69881       result = Dali::Toolkit::PushButton::DownCast(arg1);
69882     } catch (std::out_of_range& e) {
69883       {
69884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69885       };
69886     } catch (std::exception& e) {
69887       {
69888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69889       };
69890     } catch (Dali::DaliException e) {
69891       {
69892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69893       };
69894     } catch (...) {
69895       {
69896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69897       };
69898     }
69899   }
69900
69901   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
69902   return jresult;
69903 }
69904
69905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
69906   void * jresult ;
69907   Dali::Toolkit::RadioButton *result = 0 ;
69908
69909   {
69910     try {
69911       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
69912     } catch (std::out_of_range& e) {
69913       {
69914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69915       };
69916     } catch (std::exception& e) {
69917       {
69918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69919       };
69920     } catch (Dali::DaliException e) {
69921       {
69922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69923       };
69924     } catch (...) {
69925       {
69926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69927       };
69928     }
69929   }
69930
69931   jresult = (void *)result;
69932   return jresult;
69933 }
69934
69935
69936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
69937   void * jresult ;
69938   Dali::Toolkit::RadioButton *arg1 = 0 ;
69939   Dali::Toolkit::RadioButton *result = 0 ;
69940
69941   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
69942   if (!arg1) {
69943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
69944     return 0;
69945   }
69946   {
69947     try {
69948       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
69949     } catch (std::out_of_range& e) {
69950       {
69951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69952       };
69953     } catch (std::exception& e) {
69954       {
69955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69956       };
69957     } catch (Dali::DaliException e) {
69958       {
69959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69960       };
69961     } catch (...) {
69962       {
69963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69964       };
69965     }
69966   }
69967
69968   jresult = (void *)result;
69969   return jresult;
69970 }
69971
69972
69973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
69974   void * jresult ;
69975   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
69976   Dali::Toolkit::RadioButton *arg2 = 0 ;
69977   Dali::Toolkit::RadioButton *result = 0 ;
69978
69979   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
69980   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
69981   if (!arg2) {
69982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
69983     return 0;
69984   }
69985   {
69986     try {
69987       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
69988     } catch (std::out_of_range& e) {
69989       {
69990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69991       };
69992     } catch (std::exception& e) {
69993       {
69994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69995       };
69996     } catch (Dali::DaliException e) {
69997       {
69998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69999       };
70000     } catch (...) {
70001       {
70002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70003       };
70004     }
70005   }
70006
70007   jresult = (void *)result;
70008   return jresult;
70009 }
70010
70011
70012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
70013   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
70014
70015   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
70016   {
70017     try {
70018       delete arg1;
70019     } catch (std::out_of_range& e) {
70020       {
70021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70022       };
70023     } catch (std::exception& e) {
70024       {
70025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70026       };
70027     } catch (Dali::DaliException e) {
70028       {
70029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70030       };
70031     } catch (...) {
70032       {
70033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70034       };
70035     }
70036   }
70037
70038 }
70039
70040
70041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
70042   void * jresult ;
70043   Dali::Toolkit::RadioButton result;
70044
70045   {
70046     try {
70047       result = Dali::Toolkit::RadioButton::New();
70048     } catch (std::out_of_range& e) {
70049       {
70050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70051       };
70052     } catch (std::exception& e) {
70053       {
70054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70055       };
70056     } catch (Dali::DaliException e) {
70057       {
70058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70059       };
70060     } catch (...) {
70061       {
70062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70063       };
70064     }
70065   }
70066
70067   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70068   return jresult;
70069 }
70070
70071
70072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
70073   void * jresult ;
70074   std::string *arg1 = 0 ;
70075   Dali::Toolkit::RadioButton result;
70076
70077   if (!jarg1) {
70078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70079     return 0;
70080   }
70081   std::string arg1_str(jarg1);
70082   arg1 = &arg1_str;
70083   {
70084     try {
70085       result = Dali::Toolkit::RadioButton::New((std::string 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 = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70106
70107   //argout typemap for const std::string&
70108
70109   return jresult;
70110 }
70111
70112
70113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
70114   void * jresult ;
70115   Dali::BaseHandle arg1 ;
70116   Dali::BaseHandle *argp1 ;
70117   Dali::Toolkit::RadioButton result;
70118
70119   argp1 = (Dali::BaseHandle *)jarg1;
70120   if (!argp1) {
70121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70122     return 0;
70123   }
70124   arg1 = *argp1;
70125   {
70126     try {
70127       result = Dali::Toolkit::RadioButton::DownCast(arg1);
70128     } catch (std::out_of_range& e) {
70129       {
70130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70131       };
70132     } catch (std::exception& e) {
70133       {
70134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70135       };
70136     } catch (Dali::DaliException e) {
70137       {
70138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70139       };
70140     } catch (...) {
70141       {
70142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70143       };
70144     }
70145   }
70146
70147   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70148   return jresult;
70149 }
70150
70151
70152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
70153   int jresult ;
70154   int result;
70155
70156   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
70157   jresult = (int)result;
70158   return jresult;
70159 }
70160
70161
70162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
70163   int jresult ;
70164   int result;
70165
70166   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
70167   jresult = (int)result;
70168   return jresult;
70169 }
70170
70171
70172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
70173   int jresult ;
70174   int result;
70175
70176   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
70177   jresult = (int)result;
70178   return jresult;
70179 }
70180
70181
70182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
70183   int jresult ;
70184   int result;
70185
70186   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
70187   jresult = (int)result;
70188   return jresult;
70189 }
70190
70191
70192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
70193   int jresult ;
70194   int result;
70195
70196   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
70197   jresult = (int)result;
70198   return jresult;
70199 }
70200
70201
70202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
70203   int jresult ;
70204   int result;
70205
70206   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
70207   jresult = (int)result;
70208   return jresult;
70209 }
70210
70211
70212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
70213   void * jresult ;
70214   Dali::Toolkit::FlexContainer::Property *result = 0 ;
70215
70216   {
70217     try {
70218       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
70219     } catch (std::out_of_range& e) {
70220       {
70221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70222       };
70223     } catch (std::exception& e) {
70224       {
70225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70226       };
70227     } catch (Dali::DaliException e) {
70228       {
70229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70230       };
70231     } catch (...) {
70232       {
70233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70234       };
70235     }
70236   }
70237
70238   jresult = (void *)result;
70239   return jresult;
70240 }
70241
70242
70243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
70244   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
70245
70246   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
70247   {
70248     try {
70249       delete arg1;
70250     } catch (std::out_of_range& e) {
70251       {
70252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70253       };
70254     } catch (std::exception& e) {
70255       {
70256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70257       };
70258     } catch (Dali::DaliException e) {
70259       {
70260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70261       };
70262     } catch (...) {
70263       {
70264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70265       };
70266     }
70267   }
70268
70269 }
70270
70271
70272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
70273   int jresult ;
70274   int result;
70275
70276   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
70277   jresult = (int)result;
70278   return jresult;
70279 }
70280
70281
70282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
70283   int jresult ;
70284   int result;
70285
70286   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
70287   jresult = (int)result;
70288   return jresult;
70289 }
70290
70291
70292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
70293   int jresult ;
70294   int result;
70295
70296   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
70297   jresult = (int)result;
70298   return jresult;
70299 }
70300
70301
70302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
70303   void * jresult ;
70304   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
70305
70306   {
70307     try {
70308       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
70309     } catch (std::out_of_range& e) {
70310       {
70311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70312       };
70313     } catch (std::exception& e) {
70314       {
70315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70316       };
70317     } catch (Dali::DaliException e) {
70318       {
70319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70320       };
70321     } catch (...) {
70322       {
70323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70324       };
70325     }
70326   }
70327
70328   jresult = (void *)result;
70329   return jresult;
70330 }
70331
70332
70333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
70334   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
70335
70336   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
70337   {
70338     try {
70339       delete arg1;
70340     } catch (std::out_of_range& e) {
70341       {
70342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70343       };
70344     } catch (std::exception& e) {
70345       {
70346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70347       };
70348     } catch (Dali::DaliException e) {
70349       {
70350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70351       };
70352     } catch (...) {
70353       {
70354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70355       };
70356     }
70357   }
70358
70359 }
70360
70361
70362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
70363   void * jresult ;
70364   Dali::Toolkit::FlexContainer *result = 0 ;
70365
70366   {
70367     try {
70368       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
70369     } catch (std::out_of_range& e) {
70370       {
70371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70372       };
70373     } catch (std::exception& e) {
70374       {
70375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70376       };
70377     } catch (Dali::DaliException e) {
70378       {
70379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70380       };
70381     } catch (...) {
70382       {
70383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70384       };
70385     }
70386   }
70387
70388   jresult = (void *)result;
70389   return jresult;
70390 }
70391
70392
70393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
70394   void * jresult ;
70395   Dali::Toolkit::FlexContainer *arg1 = 0 ;
70396   Dali::Toolkit::FlexContainer *result = 0 ;
70397
70398   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
70399   if (!arg1) {
70400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
70401     return 0;
70402   }
70403   {
70404     try {
70405       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
70406     } catch (std::out_of_range& e) {
70407       {
70408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70409       };
70410     } catch (std::exception& e) {
70411       {
70412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70413       };
70414     } catch (Dali::DaliException e) {
70415       {
70416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70417       };
70418     } catch (...) {
70419       {
70420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70421       };
70422     }
70423   }
70424
70425   jresult = (void *)result;
70426   return jresult;
70427 }
70428
70429
70430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
70431   void * jresult ;
70432   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
70433   Dali::Toolkit::FlexContainer *arg2 = 0 ;
70434   Dali::Toolkit::FlexContainer *result = 0 ;
70435
70436   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
70437   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
70438   if (!arg2) {
70439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
70440     return 0;
70441   }
70442   {
70443     try {
70444       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
70445     } catch (std::out_of_range& e) {
70446       {
70447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70448       };
70449     } catch (std::exception& e) {
70450       {
70451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70452       };
70453     } catch (Dali::DaliException e) {
70454       {
70455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70456       };
70457     } catch (...) {
70458       {
70459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70460       };
70461     }
70462   }
70463
70464   jresult = (void *)result;
70465   return jresult;
70466 }
70467
70468
70469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
70470   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
70471
70472   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
70473   {
70474     try {
70475       delete arg1;
70476     } catch (std::out_of_range& e) {
70477       {
70478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70479       };
70480     } catch (std::exception& e) {
70481       {
70482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70483       };
70484     } catch (Dali::DaliException e) {
70485       {
70486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70487       };
70488     } catch (...) {
70489       {
70490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70491       };
70492     }
70493   }
70494
70495 }
70496
70497
70498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
70499   void * jresult ;
70500   Dali::Toolkit::FlexContainer result;
70501
70502   {
70503     try {
70504       result = Dali::Toolkit::FlexContainer::New();
70505     } catch (std::out_of_range& e) {
70506       {
70507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70508       };
70509     } catch (std::exception& e) {
70510       {
70511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70512       };
70513     } catch (Dali::DaliException e) {
70514       {
70515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70516       };
70517     } catch (...) {
70518       {
70519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70520       };
70521     }
70522   }
70523
70524   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
70525   return jresult;
70526 }
70527
70528
70529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
70530   void * jresult ;
70531   Dali::BaseHandle arg1 ;
70532   Dali::BaseHandle *argp1 ;
70533   Dali::Toolkit::FlexContainer result;
70534
70535   argp1 = (Dali::BaseHandle *)jarg1;
70536   if (!argp1) {
70537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70538     return 0;
70539   }
70540   arg1 = *argp1;
70541   {
70542     try {
70543       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
70544     } catch (std::out_of_range& e) {
70545       {
70546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70547       };
70548     } catch (std::exception& e) {
70549       {
70550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70551       };
70552     } catch (Dali::DaliException e) {
70553       {
70554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70555       };
70556     } catch (...) {
70557       {
70558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70559       };
70560     }
70561   }
70562
70563   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
70564   return jresult;
70565 }
70566
70567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
70568   int jresult ;
70569   int result;
70570
70571   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
70572   jresult = (int)result;
70573   return jresult;
70574 }
70575
70576
70577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
70578   int jresult ;
70579   int result;
70580
70581   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
70582   jresult = (int)result;
70583   return jresult;
70584 }
70585
70586
70587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
70588   int jresult ;
70589   int result;
70590
70591   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
70592   jresult = (int)result;
70593   return jresult;
70594 }
70595
70596
70597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
70598   void * jresult ;
70599   Dali::Toolkit::ImageView::Property *result = 0 ;
70600
70601   {
70602     try {
70603       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
70604     } catch (std::out_of_range& e) {
70605       {
70606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70607       };
70608     } catch (std::exception& e) {
70609       {
70610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70611       };
70612     } catch (Dali::DaliException e) {
70613       {
70614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70615       };
70616     } catch (...) {
70617       {
70618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70619       };
70620     }
70621   }
70622
70623   jresult = (void *)result;
70624   return jresult;
70625 }
70626
70627
70628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
70629   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
70630
70631   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
70632   {
70633     try {
70634       delete arg1;
70635     } catch (std::out_of_range& e) {
70636       {
70637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70638       };
70639     } catch (std::exception& e) {
70640       {
70641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70642       };
70643     } catch (Dali::DaliException e) {
70644       {
70645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70646       };
70647     } catch (...) {
70648       {
70649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70650       };
70651     }
70652   }
70653
70654 }
70655
70656
70657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
70658   void * jresult ;
70659   Dali::Toolkit::ImageView *result = 0 ;
70660
70661   {
70662     try {
70663       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
70664     } catch (std::out_of_range& e) {
70665       {
70666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70667       };
70668     } catch (std::exception& e) {
70669       {
70670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70671       };
70672     } catch (Dali::DaliException e) {
70673       {
70674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70675       };
70676     } catch (...) {
70677       {
70678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70679       };
70680     }
70681   }
70682
70683   jresult = (void *)result;
70684   return jresult;
70685 }
70686
70687
70688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
70689   void * jresult ;
70690   Dali::Toolkit::ImageView result;
70691
70692   {
70693     try {
70694       result = Dali::Toolkit::ImageView::New();
70695     } catch (std::out_of_range& e) {
70696       {
70697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70698       };
70699     } catch (std::exception& e) {
70700       {
70701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70702       };
70703     } catch (Dali::DaliException e) {
70704       {
70705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70706       };
70707     } catch (...) {
70708       {
70709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70710       };
70711     }
70712   }
70713
70714   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70715   return jresult;
70716 }
70717
70718
70719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
70720   void * jresult ;
70721   Dali::Image arg1 ;
70722   Dali::Image *argp1 ;
70723   Dali::Toolkit::ImageView result;
70724
70725   argp1 = (Dali::Image *)jarg1;
70726   if (!argp1) {
70727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70728     return 0;
70729   }
70730   arg1 = *argp1;
70731   {
70732     try {
70733       result = Dali::Toolkit::ImageView::New(arg1);
70734     } catch (std::out_of_range& e) {
70735       {
70736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70737       };
70738     } catch (std::exception& e) {
70739       {
70740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70741       };
70742     } catch (Dali::DaliException e) {
70743       {
70744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70745       };
70746     } catch (...) {
70747       {
70748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70749       };
70750     }
70751   }
70752
70753   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70754   return jresult;
70755 }
70756
70757
70758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
70759   void * jresult ;
70760   std::string *arg1 = 0 ;
70761   Dali::Toolkit::ImageView result;
70762
70763   if (!jarg1) {
70764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70765     return 0;
70766   }
70767   std::string arg1_str(jarg1);
70768   arg1 = &arg1_str;
70769   {
70770     try {
70771       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
70772     } catch (std::out_of_range& e) {
70773       {
70774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70775       };
70776     } catch (std::exception& e) {
70777       {
70778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70779       };
70780     } catch (Dali::DaliException e) {
70781       {
70782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70783       };
70784     } catch (...) {
70785       {
70786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70787       };
70788     }
70789   }
70790
70791   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70792
70793   //argout typemap for const std::string&
70794
70795   return jresult;
70796 }
70797
70798
70799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
70800   void * jresult ;
70801   std::string *arg1 = 0 ;
70802   Dali::ImageDimensions arg2 ;
70803   Dali::ImageDimensions *argp2 ;
70804   Dali::Toolkit::ImageView result;
70805
70806   if (!jarg1) {
70807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70808     return 0;
70809   }
70810   std::string arg1_str(jarg1);
70811   arg1 = &arg1_str;
70812   argp2 = (Dali::ImageDimensions *)jarg2;
70813   if (!argp2) {
70814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
70815     return 0;
70816   }
70817   arg2 = *argp2;
70818   {
70819     try {
70820       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
70821     } catch (std::out_of_range& e) {
70822       {
70823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70824       };
70825     } catch (std::exception& e) {
70826       {
70827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70828       };
70829     } catch (Dali::DaliException e) {
70830       {
70831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70832       };
70833     } catch (...) {
70834       {
70835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70836       };
70837     }
70838   }
70839
70840   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70841
70842   //argout typemap for const std::string&
70843
70844   return jresult;
70845 }
70846
70847
70848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
70849   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70850
70851   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70852   {
70853     try {
70854       delete arg1;
70855     } catch (std::out_of_range& e) {
70856       {
70857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70858       };
70859     } catch (std::exception& e) {
70860       {
70861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70862       };
70863     } catch (Dali::DaliException e) {
70864       {
70865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70866       };
70867     } catch (...) {
70868       {
70869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70870       };
70871     }
70872   }
70873
70874 }
70875
70876
70877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
70878   void * jresult ;
70879   Dali::Toolkit::ImageView *arg1 = 0 ;
70880   Dali::Toolkit::ImageView *result = 0 ;
70881
70882   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70883   if (!arg1) {
70884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
70885     return 0;
70886   }
70887   {
70888     try {
70889       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
70890     } catch (std::out_of_range& e) {
70891       {
70892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70893       };
70894     } catch (std::exception& e) {
70895       {
70896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70897       };
70898     } catch (Dali::DaliException e) {
70899       {
70900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70901       };
70902     } catch (...) {
70903       {
70904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70905       };
70906     }
70907   }
70908
70909   jresult = (void *)result;
70910   return jresult;
70911 }
70912
70913
70914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
70915   void * jresult ;
70916   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70917   Dali::Toolkit::ImageView *arg2 = 0 ;
70918   Dali::Toolkit::ImageView *result = 0 ;
70919
70920   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70921   arg2 = (Dali::Toolkit::ImageView *)jarg2;
70922   if (!arg2) {
70923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
70924     return 0;
70925   }
70926   {
70927     try {
70928       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
70929     } catch (std::out_of_range& e) {
70930       {
70931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70932       };
70933     } catch (std::exception& e) {
70934       {
70935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70936       };
70937     } catch (Dali::DaliException e) {
70938       {
70939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70940       };
70941     } catch (...) {
70942       {
70943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70944       };
70945     }
70946   }
70947
70948   jresult = (void *)result;
70949   return jresult;
70950 }
70951
70952
70953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
70954   void * jresult ;
70955   Dali::BaseHandle arg1 ;
70956   Dali::BaseHandle *argp1 ;
70957   Dali::Toolkit::ImageView result;
70958
70959   argp1 = (Dali::BaseHandle *)jarg1;
70960   if (!argp1) {
70961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70962     return 0;
70963   }
70964   arg1 = *argp1;
70965   {
70966     try {
70967       result = Dali::Toolkit::ImageView::DownCast(arg1);
70968     } catch (std::out_of_range& e) {
70969       {
70970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70971       };
70972     } catch (std::exception& e) {
70973       {
70974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70975       };
70976     } catch (Dali::DaliException e) {
70977       {
70978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70979       };
70980     } catch (...) {
70981       {
70982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70983       };
70984     }
70985   }
70986
70987   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70988   return jresult;
70989 }
70990
70991
70992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
70993   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70994   Dali::Image arg2 ;
70995   Dali::Image *argp2 ;
70996
70997   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70998   argp2 = (Dali::Image *)jarg2;
70999   if (!argp2) {
71000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71001     return ;
71002   }
71003   arg2 = *argp2;
71004   {
71005     try {
71006       (arg1)->SetImage(arg2);
71007     } catch (std::out_of_range& e) {
71008       {
71009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71010       };
71011     } catch (std::exception& e) {
71012       {
71013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71014       };
71015     } catch (Dali::DaliException e) {
71016       {
71017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71018       };
71019     } catch (...) {
71020       {
71021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71022       };
71023     }
71024   }
71025
71026 }
71027
71028
71029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
71030   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71031   std::string *arg2 = 0 ;
71032
71033   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71034   if (!jarg2) {
71035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71036     return ;
71037   }
71038   std::string arg2_str(jarg2);
71039   arg2 = &arg2_str;
71040   {
71041     try {
71042       (arg1)->SetImage((std::string const &)*arg2);
71043     } catch (std::out_of_range& e) {
71044       {
71045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71046       };
71047     } catch (std::exception& e) {
71048       {
71049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71050       };
71051     } catch (Dali::DaliException e) {
71052       {
71053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71054       };
71055     } catch (...) {
71056       {
71057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71058       };
71059     }
71060   }
71061
71062
71063   //argout typemap for const std::string&
71064
71065 }
71066
71067
71068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
71069   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71070   std::string *arg2 = 0 ;
71071   Dali::ImageDimensions arg3 ;
71072   Dali::ImageDimensions *argp3 ;
71073
71074   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71075   if (!jarg2) {
71076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71077     return ;
71078   }
71079   std::string arg2_str(jarg2);
71080   arg2 = &arg2_str;
71081   argp3 = (Dali::ImageDimensions *)jarg3;
71082   if (!argp3) {
71083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
71084     return ;
71085   }
71086   arg3 = *argp3;
71087   {
71088     try {
71089       (arg1)->SetImage((std::string const &)*arg2,arg3);
71090     } catch (std::out_of_range& e) {
71091       {
71092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71093       };
71094     } catch (std::exception& e) {
71095       {
71096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71097       };
71098     } catch (Dali::DaliException e) {
71099       {
71100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71101       };
71102     } catch (...) {
71103       {
71104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71105       };
71106     }
71107   }
71108
71109
71110   //argout typemap for const std::string&
71111
71112 }
71113
71114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
71115   void * jresult ;
71116   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71117   Dali::Image result;
71118
71119   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71120   {
71121     try {
71122       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
71123     } catch (std::out_of_range& e) {
71124       {
71125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71126       };
71127     } catch (std::exception& e) {
71128       {
71129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71130       };
71131     } catch (Dali::DaliException e) {
71132       {
71133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71134       };
71135     } catch (...) {
71136       {
71137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71138       };
71139     }
71140   }
71141
71142   jresult = new Dali::Image((const Dali::Image &)result);
71143   return jresult;
71144 }
71145
71146
71147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
71148   int jresult ;
71149   int result;
71150
71151   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
71152   jresult = (int)result;
71153   return jresult;
71154 }
71155
71156
71157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
71158   int jresult ;
71159   int result;
71160
71161   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
71162   jresult = (int)result;
71163   return jresult;
71164 }
71165
71166
71167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
71168   int jresult ;
71169   int result;
71170
71171   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
71172   jresult = (int)result;
71173   return jresult;
71174 }
71175
71176
71177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
71178   int jresult ;
71179   int result;
71180
71181   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
71182   jresult = (int)result;
71183   return jresult;
71184 }
71185
71186
71187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
71188   int jresult ;
71189   int result;
71190
71191   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
71192   jresult = (int)result;
71193   return jresult;
71194 }
71195
71196
71197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
71198   int jresult ;
71199   int result;
71200
71201   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
71202   jresult = (int)result;
71203   return jresult;
71204 }
71205
71206
71207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
71208   int jresult ;
71209   int result;
71210
71211   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
71212   jresult = (int)result;
71213   return jresult;
71214 }
71215
71216
71217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
71218   int jresult ;
71219   int result;
71220
71221   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
71222   jresult = (int)result;
71223   return jresult;
71224 }
71225
71226
71227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
71228   void * jresult ;
71229   Dali::Toolkit::Model3dView::Property *result = 0 ;
71230
71231   {
71232     try {
71233       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
71234     } catch (std::out_of_range& e) {
71235       {
71236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71237       };
71238     } catch (std::exception& e) {
71239       {
71240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71241       };
71242     } catch (Dali::DaliException e) {
71243       {
71244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71245       };
71246     } catch (...) {
71247       {
71248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71249       };
71250     }
71251   }
71252
71253   jresult = (void *)result;
71254   return jresult;
71255 }
71256
71257
71258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
71259   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
71260
71261   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
71262   {
71263     try {
71264       delete arg1;
71265     } catch (std::out_of_range& e) {
71266       {
71267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71268       };
71269     } catch (std::exception& e) {
71270       {
71271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71272       };
71273     } catch (Dali::DaliException e) {
71274       {
71275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71276       };
71277     } catch (...) {
71278       {
71279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71280       };
71281     }
71282   }
71283
71284 }
71285
71286
71287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
71288   void * jresult ;
71289   Dali::Toolkit::Model3dView result;
71290
71291   {
71292     try {
71293       result = Dali::Toolkit::Model3dView::New();
71294     } catch (std::out_of_range& e) {
71295       {
71296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71297       };
71298     } catch (std::exception& e) {
71299       {
71300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71301       };
71302     } catch (Dali::DaliException e) {
71303       {
71304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71305       };
71306     } catch (...) {
71307       {
71308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71309       };
71310     }
71311   }
71312
71313   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
71314   return jresult;
71315 }
71316
71317
71318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
71319   void * jresult ;
71320   std::string *arg1 = 0 ;
71321   std::string *arg2 = 0 ;
71322   std::string *arg3 = 0 ;
71323   Dali::Toolkit::Model3dView result;
71324
71325   if (!jarg1) {
71326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71327     return 0;
71328   }
71329   std::string arg1_str(jarg1);
71330   arg1 = &arg1_str;
71331   if (!jarg2) {
71332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71333     return 0;
71334   }
71335   std::string arg2_str(jarg2);
71336   arg2 = &arg2_str;
71337   if (!jarg3) {
71338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71339     return 0;
71340   }
71341   std::string arg3_str(jarg3);
71342   arg3 = &arg3_str;
71343   {
71344     try {
71345       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
71346     } catch (std::out_of_range& e) {
71347       {
71348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71349       };
71350     } catch (std::exception& e) {
71351       {
71352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71353       };
71354     } catch (Dali::DaliException e) {
71355       {
71356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71357       };
71358     } catch (...) {
71359       {
71360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71361       };
71362     }
71363   }
71364
71365   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
71366
71367   //argout typemap for const std::string&
71368
71369
71370   //argout typemap for const std::string&
71371
71372
71373   //argout typemap for const std::string&
71374
71375   return jresult;
71376 }
71377
71378
71379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
71380   void * jresult ;
71381   Dali::Toolkit::Model3dView *result = 0 ;
71382
71383   {
71384     try {
71385       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
71386     } catch (std::out_of_range& e) {
71387       {
71388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71389       };
71390     } catch (std::exception& e) {
71391       {
71392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71393       };
71394     } catch (Dali::DaliException e) {
71395       {
71396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71397       };
71398     } catch (...) {
71399       {
71400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71401       };
71402     }
71403   }
71404
71405   jresult = (void *)result;
71406   return jresult;
71407 }
71408
71409
71410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
71411   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
71412
71413   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
71414   {
71415     try {
71416       delete arg1;
71417     } catch (std::out_of_range& e) {
71418       {
71419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71420       };
71421     } catch (std::exception& e) {
71422       {
71423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71424       };
71425     } catch (Dali::DaliException e) {
71426       {
71427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71428       };
71429     } catch (...) {
71430       {
71431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71432       };
71433     }
71434   }
71435
71436 }
71437
71438
71439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
71440   void * jresult ;
71441   Dali::Toolkit::Model3dView *arg1 = 0 ;
71442   Dali::Toolkit::Model3dView *result = 0 ;
71443
71444   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
71445   if (!arg1) {
71446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
71447     return 0;
71448   }
71449   {
71450     try {
71451       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
71452     } catch (std::out_of_range& e) {
71453       {
71454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71455       };
71456     } catch (std::exception& e) {
71457       {
71458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71459       };
71460     } catch (Dali::DaliException e) {
71461       {
71462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71463       };
71464     } catch (...) {
71465       {
71466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71467       };
71468     }
71469   }
71470
71471   jresult = (void *)result;
71472   return jresult;
71473 }
71474
71475
71476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
71477   void * jresult ;
71478   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
71479   Dali::Toolkit::Model3dView *arg2 = 0 ;
71480   Dali::Toolkit::Model3dView *result = 0 ;
71481
71482   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
71483   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
71484   if (!arg2) {
71485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
71486     return 0;
71487   }
71488   {
71489     try {
71490       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
71491     } catch (std::out_of_range& e) {
71492       {
71493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71494       };
71495     } catch (std::exception& e) {
71496       {
71497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71498       };
71499     } catch (Dali::DaliException e) {
71500       {
71501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71502       };
71503     } catch (...) {
71504       {
71505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71506       };
71507     }
71508   }
71509
71510   jresult = (void *)result;
71511   return jresult;
71512 }
71513
71514
71515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
71516   void * jresult ;
71517   Dali::BaseHandle arg1 ;
71518   Dali::BaseHandle *argp1 ;
71519   Dali::Toolkit::Model3dView result;
71520
71521   argp1 = (Dali::BaseHandle *)jarg1;
71522   if (!argp1) {
71523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71524     return 0;
71525   }
71526   arg1 = *argp1;
71527   {
71528     try {
71529       result = Dali::Toolkit::Model3dView::DownCast(arg1);
71530     } catch (std::out_of_range& e) {
71531       {
71532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71533       };
71534     } catch (std::exception& e) {
71535       {
71536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71537       };
71538     } catch (Dali::DaliException e) {
71539       {
71540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71541       };
71542     } catch (...) {
71543       {
71544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71545       };
71546     }
71547   }
71548
71549   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
71550   return jresult;
71551 }
71552
71553
71554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
71555   int jresult ;
71556   int result;
71557
71558   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
71559   jresult = (int)result;
71560   return jresult;
71561 }
71562
71563
71564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
71565   int jresult ;
71566   int result;
71567
71568   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
71569   jresult = (int)result;
71570   return jresult;
71571 }
71572
71573
71574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
71575   int jresult ;
71576   int result;
71577
71578   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
71579   jresult = (int)result;
71580   return jresult;
71581 }
71582
71583
71584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
71585   int jresult ;
71586   int result;
71587
71588   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
71589   jresult = (int)result;
71590   return jresult;
71591 }
71592
71593
71594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
71595   int jresult ;
71596   int result;
71597
71598   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
71599   jresult = (int)result;
71600   return jresult;
71601 }
71602
71603
71604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
71605   int jresult ;
71606   int result;
71607
71608   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
71609   jresult = (int)result;
71610   return jresult;
71611 }
71612
71613
71614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
71615   int jresult ;
71616   int result;
71617
71618   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
71619   jresult = (int)result;
71620   return jresult;
71621 }
71622
71623
71624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
71625   int jresult ;
71626   int result;
71627
71628   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
71629   jresult = (int)result;
71630   return jresult;
71631 }
71632
71633
71634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
71635   int jresult ;
71636   int result;
71637
71638   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
71639   jresult = (int)result;
71640   return jresult;
71641 }
71642
71643
71644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
71645   void * jresult ;
71646   Dali::Toolkit::ScrollBar::Property *result = 0 ;
71647
71648   {
71649     try {
71650       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
71651     } catch (std::out_of_range& e) {
71652       {
71653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71654       };
71655     } catch (std::exception& e) {
71656       {
71657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71658       };
71659     } catch (Dali::DaliException e) {
71660       {
71661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71662       };
71663     } catch (...) {
71664       {
71665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71666       };
71667     }
71668   }
71669
71670   jresult = (void *)result;
71671   return jresult;
71672 }
71673
71674
71675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
71676   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
71677
71678   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
71679   {
71680     try {
71681       delete arg1;
71682     } catch (std::out_of_range& e) {
71683       {
71684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71685       };
71686     } catch (std::exception& e) {
71687       {
71688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71689       };
71690     } catch (Dali::DaliException e) {
71691       {
71692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71693       };
71694     } catch (...) {
71695       {
71696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71697       };
71698     }
71699   }
71700
71701 }
71702
71703
71704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
71705   void * jresult ;
71706   Dali::Toolkit::ScrollBar *result = 0 ;
71707
71708   {
71709     try {
71710       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
71711     } catch (std::out_of_range& e) {
71712       {
71713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71714       };
71715     } catch (std::exception& e) {
71716       {
71717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71718       };
71719     } catch (Dali::DaliException e) {
71720       {
71721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71722       };
71723     } catch (...) {
71724       {
71725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71726       };
71727     }
71728   }
71729
71730   jresult = (void *)result;
71731   return jresult;
71732 }
71733
71734
71735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
71736   void * jresult ;
71737   Dali::Toolkit::ScrollBar *arg1 = 0 ;
71738   Dali::Toolkit::ScrollBar *result = 0 ;
71739
71740   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71741   if (!arg1) {
71742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
71743     return 0;
71744   }
71745   {
71746     try {
71747       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
71748     } catch (std::out_of_range& e) {
71749       {
71750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71751       };
71752     } catch (std::exception& e) {
71753       {
71754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71755       };
71756     } catch (Dali::DaliException e) {
71757       {
71758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71759       };
71760     } catch (...) {
71761       {
71762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71763       };
71764     }
71765   }
71766
71767   jresult = (void *)result;
71768   return jresult;
71769 }
71770
71771
71772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
71773   void * jresult ;
71774   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71775   Dali::Toolkit::ScrollBar *arg2 = 0 ;
71776   Dali::Toolkit::ScrollBar *result = 0 ;
71777
71778   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71779   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
71780   if (!arg2) {
71781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
71782     return 0;
71783   }
71784   {
71785     try {
71786       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
71787     } catch (std::out_of_range& e) {
71788       {
71789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71790       };
71791     } catch (std::exception& e) {
71792       {
71793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71794       };
71795     } catch (Dali::DaliException e) {
71796       {
71797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71798       };
71799     } catch (...) {
71800       {
71801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71802       };
71803     }
71804   }
71805
71806   jresult = (void *)result;
71807   return jresult;
71808 }
71809
71810
71811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
71812   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71813
71814   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71815   {
71816     try {
71817       delete arg1;
71818     } catch (std::out_of_range& e) {
71819       {
71820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71821       };
71822     } catch (std::exception& e) {
71823       {
71824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71825       };
71826     } catch (Dali::DaliException e) {
71827       {
71828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71829       };
71830     } catch (...) {
71831       {
71832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71833       };
71834     }
71835   }
71836
71837 }
71838
71839
71840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
71841   void * jresult ;
71842   Dali::Toolkit::ScrollBar::Direction arg1 ;
71843   Dali::Toolkit::ScrollBar result;
71844
71845   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
71846   {
71847     try {
71848       result = Dali::Toolkit::ScrollBar::New(arg1);
71849     } catch (std::out_of_range& e) {
71850       {
71851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71852       };
71853     } catch (std::exception& e) {
71854       {
71855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71856       };
71857     } catch (Dali::DaliException e) {
71858       {
71859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71860       };
71861     } catch (...) {
71862       {
71863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71864       };
71865     }
71866   }
71867
71868   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
71869   return jresult;
71870 }
71871
71872
71873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
71874   void * jresult ;
71875   Dali::Toolkit::ScrollBar result;
71876
71877   {
71878     try {
71879       result = Dali::Toolkit::ScrollBar::New();
71880     } catch (std::out_of_range& e) {
71881       {
71882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71883       };
71884     } catch (std::exception& e) {
71885       {
71886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71887       };
71888     } catch (Dali::DaliException e) {
71889       {
71890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71891       };
71892     } catch (...) {
71893       {
71894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71895       };
71896     }
71897   }
71898
71899   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
71900   return jresult;
71901 }
71902
71903
71904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
71905   void * jresult ;
71906   Dali::BaseHandle arg1 ;
71907   Dali::BaseHandle *argp1 ;
71908   Dali::Toolkit::ScrollBar result;
71909
71910   argp1 = (Dali::BaseHandle *)jarg1;
71911   if (!argp1) {
71912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71913     return 0;
71914   }
71915   arg1 = *argp1;
71916   {
71917     try {
71918       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
71919     } catch (std::out_of_range& e) {
71920       {
71921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71922       };
71923     } catch (std::exception& e) {
71924       {
71925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71926       };
71927     } catch (Dali::DaliException e) {
71928       {
71929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71930       };
71931     } catch (...) {
71932       {
71933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71934       };
71935     }
71936   }
71937
71938   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
71939   return jresult;
71940 }
71941
71942
71943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
71944   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71945   Dali::Handle arg2 ;
71946   Dali::Property::Index arg3 ;
71947   Dali::Property::Index arg4 ;
71948   Dali::Property::Index arg5 ;
71949   Dali::Property::Index arg6 ;
71950   Dali::Handle *argp2 ;
71951
71952   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71953   argp2 = (Dali::Handle *)jarg2;
71954   if (!argp2) {
71955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
71956     return ;
71957   }
71958   arg2 = *argp2;
71959   arg3 = (Dali::Property::Index)jarg3;
71960   arg4 = (Dali::Property::Index)jarg4;
71961   arg5 = (Dali::Property::Index)jarg5;
71962   arg6 = (Dali::Property::Index)jarg6;
71963   {
71964     try {
71965       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
71966     } catch (std::out_of_range& e) {
71967       {
71968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71969       };
71970     } catch (std::exception& e) {
71971       {
71972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71973       };
71974     } catch (Dali::DaliException e) {
71975       {
71976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71977       };
71978     } catch (...) {
71979       {
71980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71981       };
71982     }
71983   }
71984
71985 }
71986
71987
71988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
71989   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71990   Dali::Actor arg2 ;
71991   Dali::Actor *argp2 ;
71992
71993   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71994   argp2 = (Dali::Actor *)jarg2;
71995   if (!argp2) {
71996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71997     return ;
71998   }
71999   arg2 = *argp2;
72000   {
72001     try {
72002       (arg1)->SetScrollIndicator(arg2);
72003     } catch (std::out_of_range& e) {
72004       {
72005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72006       };
72007     } catch (std::exception& e) {
72008       {
72009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72010       };
72011     } catch (Dali::DaliException e) {
72012       {
72013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72014       };
72015     } catch (...) {
72016       {
72017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72018       };
72019     }
72020   }
72021
72022 }
72023
72024
72025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
72026   void * jresult ;
72027   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72028   Dali::Actor result;
72029
72030   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72031   {
72032     try {
72033       result = (arg1)->GetScrollIndicator();
72034     } catch (std::out_of_range& e) {
72035       {
72036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72037       };
72038     } catch (std::exception& e) {
72039       {
72040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72041       };
72042     } catch (Dali::DaliException e) {
72043       {
72044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72045       };
72046     } catch (...) {
72047       {
72048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72049       };
72050     }
72051   }
72052
72053   jresult = new Dali::Actor((const Dali::Actor &)result);
72054   return jresult;
72055 }
72056
72057
72058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
72059   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72060   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
72061
72062   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72063   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
72064   if (!arg2) {
72065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
72066     return ;
72067   }
72068   {
72069     try {
72070       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
72071     } catch (std::out_of_range& e) {
72072       {
72073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72074       };
72075     } catch (std::exception& e) {
72076       {
72077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72078       };
72079     } catch (Dali::DaliException e) {
72080       {
72081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72082       };
72083     } catch (...) {
72084       {
72085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72086       };
72087     }
72088   }
72089
72090 }
72091
72092
72093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
72094   void * jresult ;
72095   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72096
72097   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72098   {
72099     try {
72100       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()));
72101     } catch (std::out_of_range& e) {
72102       {
72103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72104       };
72105     } catch (std::exception& e) {
72106       {
72107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72108       };
72109     } catch (...) {
72110       {
72111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72112       };
72113     }
72114   }
72115   return jresult;
72116 }
72117
72118
72119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
72120   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72121   Dali::Toolkit::ScrollBar::Direction arg2 ;
72122
72123   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72124   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
72125   {
72126     try {
72127       (arg1)->SetScrollDirection(arg2);
72128     } catch (std::out_of_range& e) {
72129       {
72130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72131       };
72132     } catch (std::exception& e) {
72133       {
72134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72135       };
72136     } catch (Dali::DaliException e) {
72137       {
72138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72139       };
72140     } catch (...) {
72141       {
72142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72143       };
72144     }
72145   }
72146
72147 }
72148
72149
72150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
72151   int jresult ;
72152   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72153   Dali::Toolkit::ScrollBar::Direction result;
72154
72155   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72156   {
72157     try {
72158       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
72159     } catch (std::out_of_range& e) {
72160       {
72161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72162       };
72163     } catch (std::exception& e) {
72164       {
72165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72166       };
72167     } catch (Dali::DaliException e) {
72168       {
72169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72170       };
72171     } catch (...) {
72172       {
72173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72174       };
72175     }
72176   }
72177
72178   jresult = (int)result;
72179   return jresult;
72180 }
72181
72182
72183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
72184   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72185   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
72186
72187   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72188   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
72189   {
72190     try {
72191       (arg1)->SetIndicatorHeightPolicy(arg2);
72192     } catch (std::out_of_range& e) {
72193       {
72194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72195       };
72196     } catch (std::exception& e) {
72197       {
72198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72199       };
72200     } catch (Dali::DaliException e) {
72201       {
72202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72203       };
72204     } catch (...) {
72205       {
72206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72207       };
72208     }
72209   }
72210
72211 }
72212
72213
72214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
72215   int jresult ;
72216   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72217   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
72218
72219   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72220   {
72221     try {
72222       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
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 = (int)result;
72243   return jresult;
72244 }
72245
72246
72247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
72248   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72249   float arg2 ;
72250
72251   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72252   arg2 = (float)jarg2;
72253   {
72254     try {
72255       (arg1)->SetIndicatorFixedHeight(arg2);
72256     } catch (std::out_of_range& e) {
72257       {
72258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72259       };
72260     } catch (std::exception& e) {
72261       {
72262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72263       };
72264     } catch (Dali::DaliException e) {
72265       {
72266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72267       };
72268     } catch (...) {
72269       {
72270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72271       };
72272     }
72273   }
72274
72275 }
72276
72277
72278 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
72279   float jresult ;
72280   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72281   float result;
72282
72283   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72284   {
72285     try {
72286       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
72287     } catch (std::out_of_range& e) {
72288       {
72289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72290       };
72291     } catch (std::exception& e) {
72292       {
72293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72294       };
72295     } catch (Dali::DaliException e) {
72296       {
72297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72298       };
72299     } catch (...) {
72300       {
72301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72302       };
72303     }
72304   }
72305
72306   jresult = result;
72307   return jresult;
72308 }
72309
72310
72311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
72312   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72313   float arg2 ;
72314
72315   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72316   arg2 = (float)jarg2;
72317   {
72318     try {
72319       (arg1)->SetIndicatorShowDuration(arg2);
72320     } catch (std::out_of_range& e) {
72321       {
72322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72323       };
72324     } catch (std::exception& e) {
72325       {
72326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72327       };
72328     } catch (Dali::DaliException e) {
72329       {
72330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72331       };
72332     } catch (...) {
72333       {
72334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72335       };
72336     }
72337   }
72338
72339 }
72340
72341
72342 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
72343   float jresult ;
72344   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72345   float result;
72346
72347   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72348   {
72349     try {
72350       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
72351     } catch (std::out_of_range& e) {
72352       {
72353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72354       };
72355     } catch (std::exception& e) {
72356       {
72357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72358       };
72359     } catch (Dali::DaliException e) {
72360       {
72361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72362       };
72363     } catch (...) {
72364       {
72365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72366       };
72367     }
72368   }
72369
72370   jresult = result;
72371   return jresult;
72372 }
72373
72374
72375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
72376   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72377   float arg2 ;
72378
72379   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72380   arg2 = (float)jarg2;
72381   {
72382     try {
72383       (arg1)->SetIndicatorHideDuration(arg2);
72384     } catch (std::out_of_range& e) {
72385       {
72386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72387       };
72388     } catch (std::exception& e) {
72389       {
72390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72391       };
72392     } catch (Dali::DaliException e) {
72393       {
72394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72395       };
72396     } catch (...) {
72397       {
72398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72399       };
72400     }
72401   }
72402
72403 }
72404
72405
72406 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
72407   float jresult ;
72408   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72409   float result;
72410
72411   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72412   {
72413     try {
72414       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
72415     } catch (std::out_of_range& e) {
72416       {
72417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72418       };
72419     } catch (std::exception& e) {
72420       {
72421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72422       };
72423     } catch (Dali::DaliException e) {
72424       {
72425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72426       };
72427     } catch (...) {
72428       {
72429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72430       };
72431     }
72432   }
72433
72434   jresult = result;
72435   return jresult;
72436 }
72437
72438
72439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
72440   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72441
72442   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72443   {
72444     try {
72445       (arg1)->ShowIndicator();
72446     } catch (std::out_of_range& e) {
72447       {
72448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72449       };
72450     } catch (std::exception& e) {
72451       {
72452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72453       };
72454     } catch (Dali::DaliException e) {
72455       {
72456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72457       };
72458     } catch (...) {
72459       {
72460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72461       };
72462     }
72463   }
72464
72465 }
72466
72467
72468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
72469   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72470
72471   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72472   {
72473     try {
72474       (arg1)->HideIndicator();
72475     } catch (std::out_of_range& e) {
72476       {
72477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72478       };
72479     } catch (std::exception& e) {
72480       {
72481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72482       };
72483     } catch (Dali::DaliException e) {
72484       {
72485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72486       };
72487     } catch (...) {
72488       {
72489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72490       };
72491     }
72492   }
72493
72494 }
72495
72496
72497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
72498   void * jresult ;
72499   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72500   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
72501
72502   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72503   {
72504     try {
72505       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
72506     } catch (std::out_of_range& e) {
72507       {
72508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72509       };
72510     } catch (std::exception& e) {
72511       {
72512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72513       };
72514     } catch (Dali::DaliException e) {
72515       {
72516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72517       };
72518     } catch (...) {
72519       {
72520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72521       };
72522     }
72523   }
72524
72525   jresult = (void *)result;
72526   return jresult;
72527 }
72528
72529
72530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
72531   void * jresult ;
72532   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72533   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
72534
72535   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72536   {
72537     try {
72538       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
72539     } catch (std::out_of_range& e) {
72540       {
72541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72542       };
72543     } catch (std::exception& e) {
72544       {
72545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72546       };
72547     } catch (Dali::DaliException e) {
72548       {
72549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72550       };
72551     } catch (...) {
72552       {
72553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72554       };
72555     }
72556   }
72557
72558   jresult = (void *)result;
72559   return jresult;
72560 }
72561
72562
72563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
72564   int jresult ;
72565   int result;
72566
72567   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
72568   jresult = (int)result;
72569   return jresult;
72570 }
72571
72572
72573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
72574   int jresult ;
72575   int result;
72576
72577   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
72578   jresult = (int)result;
72579   return jresult;
72580 }
72581
72582
72583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
72584   int jresult ;
72585   int result;
72586
72587   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
72588   jresult = (int)result;
72589   return jresult;
72590 }
72591
72592
72593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
72594   int jresult ;
72595   int result;
72596
72597   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
72598   jresult = (int)result;
72599   return jresult;
72600 }
72601
72602
72603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
72604   int jresult ;
72605   int result;
72606
72607   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
72608   jresult = (int)result;
72609   return jresult;
72610 }
72611
72612
72613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
72614   int jresult ;
72615   int result;
72616
72617   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
72618   jresult = (int)result;
72619   return jresult;
72620 }
72621
72622
72623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
72624   int jresult ;
72625   int result;
72626
72627   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
72628   jresult = (int)result;
72629   return jresult;
72630 }
72631
72632
72633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
72634   int jresult ;
72635   int result;
72636
72637   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
72638   jresult = (int)result;
72639   return jresult;
72640 }
72641
72642
72643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
72644   int jresult ;
72645   int result;
72646
72647   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
72648   jresult = (int)result;
72649   return jresult;
72650 }
72651
72652
72653 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
72654   int jresult ;
72655   int result;
72656
72657   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
72658   jresult = (int)result;
72659   return jresult;
72660 }
72661
72662
72663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
72664   int jresult ;
72665   int result;
72666
72667   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
72668   jresult = (int)result;
72669   return jresult;
72670 }
72671
72672
72673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
72674   int jresult ;
72675   int result;
72676
72677   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
72678   jresult = (int)result;
72679   return jresult;
72680 }
72681
72682
72683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
72684   int jresult ;
72685   int result;
72686
72687   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
72688   jresult = (int)result;
72689   return jresult;
72690 }
72691
72692
72693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
72694   int jresult ;
72695   int result;
72696
72697   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
72698   jresult = (int)result;
72699   return jresult;
72700 }
72701
72702
72703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
72704   void * jresult ;
72705   Dali::Toolkit::Scrollable::Property *result = 0 ;
72706
72707   {
72708     try {
72709       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
72710     } catch (std::out_of_range& e) {
72711       {
72712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72713       };
72714     } catch (std::exception& e) {
72715       {
72716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72717       };
72718     } catch (Dali::DaliException e) {
72719       {
72720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72721       };
72722     } catch (...) {
72723       {
72724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72725       };
72726     }
72727   }
72728
72729   jresult = (void *)result;
72730   return jresult;
72731 }
72732
72733
72734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
72735   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
72736
72737   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
72738   {
72739     try {
72740       delete arg1;
72741     } catch (std::out_of_range& e) {
72742       {
72743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72744       };
72745     } catch (std::exception& e) {
72746       {
72747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72748       };
72749     } catch (Dali::DaliException e) {
72750       {
72751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72752       };
72753     } catch (...) {
72754       {
72755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72756       };
72757     }
72758   }
72759
72760 }
72761
72762
72763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
72764   void * jresult ;
72765   Dali::Toolkit::Scrollable *result = 0 ;
72766
72767   {
72768     try {
72769       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
72770     } catch (std::out_of_range& e) {
72771       {
72772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72773       };
72774     } catch (std::exception& e) {
72775       {
72776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72777       };
72778     } catch (Dali::DaliException e) {
72779       {
72780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72781       };
72782     } catch (...) {
72783       {
72784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72785       };
72786     }
72787   }
72788
72789   jresult = (void *)result;
72790   return jresult;
72791 }
72792
72793
72794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
72795   void * jresult ;
72796   Dali::Toolkit::Scrollable *arg1 = 0 ;
72797   Dali::Toolkit::Scrollable *result = 0 ;
72798
72799   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72800   if (!arg1) {
72801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
72802     return 0;
72803   }
72804   {
72805     try {
72806       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
72807     } catch (std::out_of_range& e) {
72808       {
72809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72810       };
72811     } catch (std::exception& e) {
72812       {
72813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72814       };
72815     } catch (Dali::DaliException e) {
72816       {
72817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72818       };
72819     } catch (...) {
72820       {
72821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72822       };
72823     }
72824   }
72825
72826   jresult = (void *)result;
72827   return jresult;
72828 }
72829
72830
72831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
72832   void * jresult ;
72833   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72834   Dali::Toolkit::Scrollable *arg2 = 0 ;
72835   Dali::Toolkit::Scrollable *result = 0 ;
72836
72837   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72838   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
72839   if (!arg2) {
72840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
72841     return 0;
72842   }
72843   {
72844     try {
72845       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
72846     } catch (std::out_of_range& e) {
72847       {
72848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72849       };
72850     } catch (std::exception& e) {
72851       {
72852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72853       };
72854     } catch (Dali::DaliException e) {
72855       {
72856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72857       };
72858     } catch (...) {
72859       {
72860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72861       };
72862     }
72863   }
72864
72865   jresult = (void *)result;
72866   return jresult;
72867 }
72868
72869
72870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
72871   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72872
72873   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72874   {
72875     try {
72876       delete arg1;
72877     } catch (std::out_of_range& e) {
72878       {
72879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72880       };
72881     } catch (std::exception& e) {
72882       {
72883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72884       };
72885     } catch (Dali::DaliException e) {
72886       {
72887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72888       };
72889     } catch (...) {
72890       {
72891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72892       };
72893     }
72894   }
72895
72896 }
72897
72898
72899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
72900   void * jresult ;
72901   Dali::BaseHandle arg1 ;
72902   Dali::BaseHandle *argp1 ;
72903   Dali::Toolkit::Scrollable result;
72904
72905   argp1 = (Dali::BaseHandle *)jarg1;
72906   if (!argp1) {
72907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72908     return 0;
72909   }
72910   arg1 = *argp1;
72911   {
72912     try {
72913       result = Dali::Toolkit::Scrollable::DownCast(arg1);
72914     } catch (std::out_of_range& e) {
72915       {
72916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72917       };
72918     } catch (std::exception& e) {
72919       {
72920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72921       };
72922     } catch (Dali::DaliException e) {
72923       {
72924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72925       };
72926     } catch (...) {
72927       {
72928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72929       };
72930     }
72931   }
72932
72933   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
72934   return jresult;
72935 }
72936
72937
72938 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
72939   unsigned int jresult ;
72940   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72941   bool result;
72942
72943   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72944   {
72945     try {
72946       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
72947     } catch (std::out_of_range& e) {
72948       {
72949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72950       };
72951     } catch (std::exception& e) {
72952       {
72953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72954       };
72955     } catch (Dali::DaliException e) {
72956       {
72957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72958       };
72959     } catch (...) {
72960       {
72961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72962       };
72963     }
72964   }
72965
72966   jresult = result;
72967   return jresult;
72968 }
72969
72970
72971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
72972   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72973   bool arg2 ;
72974
72975   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72976   arg2 = jarg2 ? true : false;
72977   {
72978     try {
72979       (arg1)->SetOvershootEnabled(arg2);
72980     } catch (std::out_of_range& e) {
72981       {
72982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72983       };
72984     } catch (std::exception& e) {
72985       {
72986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72987       };
72988     } catch (Dali::DaliException e) {
72989       {
72990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72991       };
72992     } catch (...) {
72993       {
72994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72995       };
72996     }
72997   }
72998
72999 }
73000
73001
73002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
73003   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73004   Dali::Vector4 *arg2 = 0 ;
73005
73006   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73007   arg2 = (Dali::Vector4 *)jarg2;
73008   if (!arg2) {
73009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
73010     return ;
73011   }
73012   {
73013     try {
73014       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
73015     } catch (std::out_of_range& e) {
73016       {
73017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73018       };
73019     } catch (std::exception& e) {
73020       {
73021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73022       };
73023     } catch (Dali::DaliException e) {
73024       {
73025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73026       };
73027     } catch (...) {
73028       {
73029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73030       };
73031     }
73032   }
73033
73034 }
73035
73036
73037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
73038   void * jresult ;
73039   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73040   Dali::Vector4 result;
73041
73042   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73043   {
73044     try {
73045       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
73046     } catch (std::out_of_range& e) {
73047       {
73048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73049       };
73050     } catch (std::exception& e) {
73051       {
73052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73053       };
73054     } catch (Dali::DaliException e) {
73055       {
73056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73057       };
73058     } catch (...) {
73059       {
73060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73061       };
73062     }
73063   }
73064
73065   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
73066   return jresult;
73067 }
73068
73069
73070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
73071   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73072   float arg2 ;
73073
73074   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73075   arg2 = (float)jarg2;
73076   {
73077     try {
73078       (arg1)->SetOvershootAnimationSpeed(arg2);
73079     } catch (std::out_of_range& e) {
73080       {
73081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73082       };
73083     } catch (std::exception& e) {
73084       {
73085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73086       };
73087     } catch (Dali::DaliException e) {
73088       {
73089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73090       };
73091     } catch (...) {
73092       {
73093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73094       };
73095     }
73096   }
73097
73098 }
73099
73100
73101 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
73102   float jresult ;
73103   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73104   float result;
73105
73106   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73107   {
73108     try {
73109       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
73110     } catch (std::out_of_range& e) {
73111       {
73112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73113       };
73114     } catch (std::exception& e) {
73115       {
73116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73117       };
73118     } catch (Dali::DaliException e) {
73119       {
73120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73121       };
73122     } catch (...) {
73123       {
73124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73125       };
73126     }
73127   }
73128
73129   jresult = result;
73130   return jresult;
73131 }
73132
73133
73134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
73135   void * jresult ;
73136   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73137   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
73138
73139   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73140   {
73141     try {
73142       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
73143     } catch (std::out_of_range& e) {
73144       {
73145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73146       };
73147     } catch (std::exception& e) {
73148       {
73149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73150       };
73151     } catch (Dali::DaliException e) {
73152       {
73153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73154       };
73155     } catch (...) {
73156       {
73157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73158       };
73159     }
73160   }
73161
73162   jresult = (void *)result;
73163   return jresult;
73164 }
73165
73166
73167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
73168   void * jresult ;
73169   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73170   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
73171
73172   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73173   {
73174     try {
73175       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
73176     } catch (std::out_of_range& e) {
73177       {
73178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73179       };
73180     } catch (std::exception& e) {
73181       {
73182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73183       };
73184     } catch (Dali::DaliException e) {
73185       {
73186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73187       };
73188     } catch (...) {
73189       {
73190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73191       };
73192     }
73193   }
73194
73195   jresult = (void *)result;
73196   return jresult;
73197 }
73198
73199
73200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
73201   void * jresult ;
73202   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73203   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
73204
73205   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73206   {
73207     try {
73208       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
73209     } catch (std::out_of_range& e) {
73210       {
73211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73212       };
73213     } catch (std::exception& e) {
73214       {
73215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73216       };
73217     } catch (Dali::DaliException e) {
73218       {
73219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73220       };
73221     } catch (...) {
73222       {
73223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73224       };
73225     }
73226   }
73227
73228   jresult = (void *)result;
73229   return jresult;
73230 }
73231
73232
73233 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
73234   unsigned int jresult ;
73235   Dali::Toolkit::ControlOrientation::Type arg1 ;
73236   bool result;
73237
73238   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
73239   {
73240     try {
73241       result = (bool)Dali::Toolkit::IsVertical(arg1);
73242     } catch (std::out_of_range& e) {
73243       {
73244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73245       };
73246     } catch (std::exception& e) {
73247       {
73248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73249       };
73250     } catch (Dali::DaliException e) {
73251       {
73252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73253       };
73254     } catch (...) {
73255       {
73256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73257       };
73258     }
73259   }
73260
73261   jresult = result;
73262   return jresult;
73263 }
73264
73265
73266 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
73267   unsigned int jresult ;
73268   Dali::Toolkit::ControlOrientation::Type arg1 ;
73269   bool result;
73270
73271   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
73272   {
73273     try {
73274       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
73275     } catch (std::out_of_range& e) {
73276       {
73277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73278       };
73279     } catch (std::exception& e) {
73280       {
73281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73282       };
73283     } catch (Dali::DaliException e) {
73284       {
73285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73286       };
73287     } catch (...) {
73288       {
73289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73290       };
73291     }
73292   }
73293
73294   jresult = result;
73295   return jresult;
73296 }
73297
73298
73299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
73300   void * jresult ;
73301   unsigned int arg1 ;
73302   unsigned int arg2 ;
73303   Dali::Toolkit::ItemRange *result = 0 ;
73304
73305   arg1 = (unsigned int)jarg1;
73306   arg2 = (unsigned int)jarg2;
73307   {
73308     try {
73309       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
73310     } catch (std::out_of_range& e) {
73311       {
73312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73313       };
73314     } catch (std::exception& e) {
73315       {
73316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73317       };
73318     } catch (Dali::DaliException e) {
73319       {
73320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73321       };
73322     } catch (...) {
73323       {
73324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73325       };
73326     }
73327   }
73328
73329   jresult = (void *)result;
73330   return jresult;
73331 }
73332
73333
73334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
73335   void * jresult ;
73336   Dali::Toolkit::ItemRange *arg1 = 0 ;
73337   Dali::Toolkit::ItemRange *result = 0 ;
73338
73339   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73340   if (!arg1) {
73341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
73342     return 0;
73343   }
73344   {
73345     try {
73346       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
73347     } catch (std::out_of_range& e) {
73348       {
73349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73350       };
73351     } catch (std::exception& e) {
73352       {
73353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73354       };
73355     } catch (Dali::DaliException e) {
73356       {
73357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73358       };
73359     } catch (...) {
73360       {
73361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73362       };
73363     }
73364   }
73365
73366   jresult = (void *)result;
73367   return jresult;
73368 }
73369
73370
73371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
73372   void * jresult ;
73373   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73374   Dali::Toolkit::ItemRange *arg2 = 0 ;
73375   Dali::Toolkit::ItemRange *result = 0 ;
73376
73377   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73378   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
73379   if (!arg2) {
73380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
73381     return 0;
73382   }
73383   {
73384     try {
73385       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
73386     } catch (std::out_of_range& e) {
73387       {
73388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73389       };
73390     } catch (std::exception& e) {
73391       {
73392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73393       };
73394     } catch (Dali::DaliException e) {
73395       {
73396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73397       };
73398     } catch (...) {
73399       {
73400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73401       };
73402     }
73403   }
73404
73405   jresult = (void *)result;
73406   return jresult;
73407 }
73408
73409
73410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
73411   unsigned int jresult ;
73412   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73413   unsigned int arg2 ;
73414   bool result;
73415
73416   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73417   arg2 = (unsigned int)jarg2;
73418   {
73419     try {
73420       result = (bool)(arg1)->Within(arg2);
73421     } catch (std::out_of_range& e) {
73422       {
73423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73424       };
73425     } catch (std::exception& e) {
73426       {
73427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73428       };
73429     } catch (Dali::DaliException e) {
73430       {
73431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73432       };
73433     } catch (...) {
73434       {
73435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73436       };
73437     }
73438   }
73439
73440   jresult = result;
73441   return jresult;
73442 }
73443
73444
73445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
73446   void * jresult ;
73447   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73448   Dali::Toolkit::ItemRange *arg2 = 0 ;
73449   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
73450
73451   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73452   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
73453   if (!arg2) {
73454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
73455     return 0;
73456   }
73457   {
73458     try {
73459       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
73460     } catch (std::out_of_range& e) {
73461       {
73462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73463       };
73464     } catch (std::exception& e) {
73465       {
73466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73467       };
73468     } catch (Dali::DaliException e) {
73469       {
73470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73471       };
73472     } catch (...) {
73473       {
73474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73475       };
73476     }
73477   }
73478
73479   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
73480   return jresult;
73481 }
73482
73483
73484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
73485   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73486   unsigned int arg2 ;
73487
73488   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73489   arg2 = (unsigned int)jarg2;
73490   if (arg1) (arg1)->begin = arg2;
73491 }
73492
73493
73494 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
73495   unsigned int jresult ;
73496   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73497   unsigned int result;
73498
73499   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73500   result = (unsigned int) ((arg1)->begin);
73501   jresult = result;
73502   return jresult;
73503 }
73504
73505
73506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
73507   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73508   unsigned int arg2 ;
73509
73510   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73511   arg2 = (unsigned int)jarg2;
73512   if (arg1) (arg1)->end = arg2;
73513 }
73514
73515
73516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
73517   unsigned int jresult ;
73518   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73519   unsigned int result;
73520
73521   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73522   result = (unsigned int) ((arg1)->end);
73523   jresult = result;
73524   return jresult;
73525 }
73526
73527
73528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
73529   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73530
73531   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73532   {
73533     try {
73534       delete arg1;
73535     } catch (std::out_of_range& e) {
73536       {
73537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73538       };
73539     } catch (std::exception& e) {
73540       {
73541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73542       };
73543     } catch (Dali::DaliException e) {
73544       {
73545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73546       };
73547     } catch (...) {
73548       {
73549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73550       };
73551     }
73552   }
73553
73554 }
73555
73556
73557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
73558   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73559
73560   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73561   {
73562     try {
73563       delete arg1;
73564     } catch (std::out_of_range& e) {
73565       {
73566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73567       };
73568     } catch (std::exception& e) {
73569       {
73570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73571       };
73572     } catch (Dali::DaliException e) {
73573       {
73574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73575       };
73576     } catch (...) {
73577       {
73578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73579       };
73580     }
73581   }
73582
73583 }
73584
73585
73586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
73587   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73588   Dali::Toolkit::ControlOrientation::Type arg2 ;
73589
73590   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73591   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
73592   {
73593     try {
73594       (arg1)->SetOrientation(arg2);
73595     } catch (std::out_of_range& e) {
73596       {
73597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73598       };
73599     } catch (std::exception& e) {
73600       {
73601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73602       };
73603     } catch (Dali::DaliException e) {
73604       {
73605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73606       };
73607     } catch (...) {
73608       {
73609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73610       };
73611     }
73612   }
73613
73614 }
73615
73616
73617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
73618   int jresult ;
73619   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73620   Dali::Toolkit::ControlOrientation::Type result;
73621
73622   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73623   {
73624     try {
73625       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
73626     } catch (std::out_of_range& e) {
73627       {
73628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73629       };
73630     } catch (std::exception& e) {
73631       {
73632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73633       };
73634     } catch (Dali::DaliException e) {
73635       {
73636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73637       };
73638     } catch (...) {
73639       {
73640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73641       };
73642     }
73643   }
73644
73645   jresult = (int)result;
73646   return jresult;
73647 }
73648
73649
73650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
73651   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73652   Dali::Property::Map *arg2 = 0 ;
73653
73654   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73655   arg2 = (Dali::Property::Map *)jarg2;
73656   if (!arg2) {
73657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
73658     return ;
73659   }
73660   {
73661     try {
73662       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
73663     } catch (std::out_of_range& e) {
73664       {
73665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73666       };
73667     } catch (std::exception& e) {
73668       {
73669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73670       };
73671     } catch (Dali::DaliException e) {
73672       {
73673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73674       };
73675     } catch (...) {
73676       {
73677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73678       };
73679     }
73680   }
73681
73682 }
73683
73684
73685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
73686   void * jresult ;
73687   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73688   Dali::Property::Map result;
73689
73690   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73691   {
73692     try {
73693       result = (arg1)->GetLayoutProperties();
73694     } catch (std::out_of_range& e) {
73695       {
73696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73697       };
73698     } catch (std::exception& e) {
73699       {
73700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73701       };
73702     } catch (Dali::DaliException e) {
73703       {
73704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73705       };
73706     } catch (...) {
73707       {
73708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73709       };
73710     }
73711   }
73712
73713   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
73714   return jresult;
73715 }
73716
73717
73718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
73719   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73720   unsigned int arg2 ;
73721   Dali::Vector3 *arg3 = 0 ;
73722   Dali::Vector3 *arg4 = 0 ;
73723
73724   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73725   arg2 = (unsigned int)jarg2;
73726   arg3 = (Dali::Vector3 *)jarg3;
73727   if (!arg3) {
73728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73729     return ;
73730   }
73731   arg4 = (Dali::Vector3 *)jarg4;
73732   if (!arg4) {
73733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
73734     return ;
73735   }
73736   {
73737     try {
73738       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
73739     } catch (std::out_of_range& e) {
73740       {
73741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73742       };
73743     } catch (std::exception& e) {
73744       {
73745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73746       };
73747     } catch (Dali::DaliException e) {
73748       {
73749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73750       };
73751     } catch (...) {
73752       {
73753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73754       };
73755     }
73756   }
73757
73758 }
73759
73760
73761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
73762   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73763   Dali::Vector3 *arg2 = 0 ;
73764
73765   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73766   arg2 = (Dali::Vector3 *)jarg2;
73767   if (!arg2) {
73768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73769     return ;
73770   }
73771   {
73772     try {
73773       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
73774     } catch (std::out_of_range& e) {
73775       {
73776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73777       };
73778     } catch (std::exception& e) {
73779       {
73780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73781       };
73782     } catch (Dali::DaliException e) {
73783       {
73784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73785       };
73786     } catch (...) {
73787       {
73788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73789       };
73790     }
73791   }
73792
73793 }
73794
73795
73796 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
73797   float jresult ;
73798   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73799   unsigned int arg2 ;
73800   Dali::Vector3 arg3 ;
73801   Dali::Vector3 *argp3 ;
73802   float result;
73803
73804   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73805   arg2 = (unsigned int)jarg2;
73806   argp3 = (Dali::Vector3 *)jarg3;
73807   if (!argp3) {
73808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
73809     return 0;
73810   }
73811   arg3 = *argp3;
73812   {
73813     try {
73814       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
73815     } catch (std::out_of_range& e) {
73816       {
73817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73818       };
73819     } catch (std::exception& e) {
73820       {
73821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73822       };
73823     } catch (Dali::DaliException e) {
73824       {
73825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73826       };
73827     } catch (...) {
73828       {
73829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73830       };
73831     }
73832   }
73833
73834   jresult = result;
73835   return jresult;
73836 }
73837
73838
73839 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
73840   float jresult ;
73841   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73842   float arg2 ;
73843   float result;
73844
73845   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73846   arg2 = (float)jarg2;
73847   {
73848     try {
73849       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
73850     } catch (std::out_of_range& e) {
73851       {
73852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73853       };
73854     } catch (std::exception& e) {
73855       {
73856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73857       };
73858     } catch (Dali::DaliException e) {
73859       {
73860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73861       };
73862     } catch (...) {
73863       {
73864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73865       };
73866     }
73867   }
73868
73869   jresult = result;
73870   return jresult;
73871 }
73872
73873
73874 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
73875   float jresult ;
73876   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73877   unsigned int arg2 ;
73878   float result;
73879
73880   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73881   arg2 = (unsigned int)jarg2;
73882   {
73883     try {
73884       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
73885     } catch (std::out_of_range& e) {
73886       {
73887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73888       };
73889     } catch (std::exception& e) {
73890       {
73891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73892       };
73893     } catch (Dali::DaliException e) {
73894       {
73895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73896       };
73897     } catch (...) {
73898       {
73899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73900       };
73901     }
73902   }
73903
73904   jresult = result;
73905   return jresult;
73906 }
73907
73908
73909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
73910   void * jresult ;
73911   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73912   float arg2 ;
73913   Dali::Vector3 arg3 ;
73914   Dali::Vector3 *argp3 ;
73915   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
73916
73917   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73918   arg2 = (float)jarg2;
73919   argp3 = (Dali::Vector3 *)jarg3;
73920   if (!argp3) {
73921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
73922     return 0;
73923   }
73924   arg3 = *argp3;
73925   {
73926     try {
73927       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
73928     } catch (std::out_of_range& e) {
73929       {
73930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73931       };
73932     } catch (std::exception& e) {
73933       {
73934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73935       };
73936     } catch (Dali::DaliException e) {
73937       {
73938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73939       };
73940     } catch (...) {
73941       {
73942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73943       };
73944     }
73945   }
73946
73947   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
73948   return jresult;
73949 }
73950
73951
73952 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
73953   float jresult ;
73954   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73955   int arg2 ;
73956   float arg3 ;
73957   Dali::Vector3 *arg4 = 0 ;
73958   float result;
73959
73960   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73961   arg2 = (int)jarg2;
73962   arg3 = (float)jarg3;
73963   arg4 = (Dali::Vector3 *)jarg4;
73964   if (!arg4) {
73965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73966     return 0;
73967   }
73968   {
73969     try {
73970       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
73971     } catch (std::out_of_range& e) {
73972       {
73973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73974       };
73975     } catch (std::exception& e) {
73976       {
73977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73978       };
73979     } catch (Dali::DaliException e) {
73980       {
73981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73982       };
73983     } catch (...) {
73984       {
73985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73986       };
73987     }
73988   }
73989
73990   jresult = result;
73991   return jresult;
73992 }
73993
73994
73995 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
73996   unsigned int jresult ;
73997   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73998   Dali::Vector3 arg2 ;
73999   Dali::Vector3 *argp2 ;
74000   unsigned int result;
74001
74002   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74003   argp2 = (Dali::Vector3 *)jarg2;
74004   if (!argp2) {
74005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74006     return 0;
74007   }
74008   arg2 = *argp2;
74009   {
74010     try {
74011       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
74012     } catch (std::out_of_range& e) {
74013       {
74014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74015       };
74016     } catch (std::exception& e) {
74017       {
74018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74019       };
74020     } catch (Dali::DaliException e) {
74021       {
74022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74023       };
74024     } catch (...) {
74025       {
74026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74027       };
74028     }
74029   }
74030
74031   jresult = result;
74032   return jresult;
74033 }
74034
74035
74036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
74037   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74038   unsigned int arg2 ;
74039   Dali::Vector3 *arg3 = 0 ;
74040   Dali::Vector3 *arg4 = 0 ;
74041
74042   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74043   arg2 = (unsigned int)jarg2;
74044   arg3 = (Dali::Vector3 *)jarg3;
74045   if (!arg3) {
74046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74047     return ;
74048   }
74049   arg4 = (Dali::Vector3 *)jarg4;
74050   if (!arg4) {
74051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
74052     return ;
74053   }
74054   {
74055     try {
74056       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
74057     } catch (std::out_of_range& e) {
74058       {
74059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74060       };
74061     } catch (std::exception& e) {
74062       {
74063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74064       };
74065     } catch (Dali::DaliException e) {
74066       {
74067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74068       };
74069     } catch (...) {
74070       {
74071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74072       };
74073     }
74074   }
74075
74076 }
74077
74078
74079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
74080   void * jresult ;
74081   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74082   Dali::Degree result;
74083
74084   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74085   {
74086     try {
74087       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
74088     } catch (std::out_of_range& e) {
74089       {
74090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74091       };
74092     } catch (std::exception& e) {
74093       {
74094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74095       };
74096     } catch (Dali::DaliException e) {
74097       {
74098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74099       };
74100     } catch (...) {
74101       {
74102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74103       };
74104     }
74105   }
74106
74107   jresult = new Dali::Degree((const Dali::Degree &)result);
74108   return jresult;
74109 }
74110
74111
74112 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
74113   float jresult ;
74114   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74115   float result;
74116
74117   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74118   {
74119     try {
74120       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
74121     } catch (std::out_of_range& e) {
74122       {
74123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74124       };
74125     } catch (std::exception& e) {
74126       {
74127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74128       };
74129     } catch (Dali::DaliException e) {
74130       {
74131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74132       };
74133     } catch (...) {
74134       {
74135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74136       };
74137     }
74138   }
74139
74140   jresult = result;
74141   return jresult;
74142 }
74143
74144
74145 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
74146   float jresult ;
74147   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74148   float result;
74149
74150   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74151   {
74152     try {
74153       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
74154     } catch (std::out_of_range& e) {
74155       {
74156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74157       };
74158     } catch (std::exception& e) {
74159       {
74160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74161       };
74162     } catch (Dali::DaliException e) {
74163       {
74164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74165       };
74166     } catch (...) {
74167       {
74168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74169       };
74170     }
74171   }
74172
74173   jresult = result;
74174   return jresult;
74175 }
74176
74177
74178 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
74179   float jresult ;
74180   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74181   float result;
74182
74183   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74184   {
74185     try {
74186       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
74187     } catch (std::out_of_range& e) {
74188       {
74189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74190       };
74191     } catch (std::exception& e) {
74192       {
74193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74194       };
74195     } catch (Dali::DaliException e) {
74196       {
74197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74198       };
74199     } catch (...) {
74200       {
74201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74202       };
74203     }
74204   }
74205
74206   jresult = result;
74207   return jresult;
74208 }
74209
74210
74211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
74212   int jresult ;
74213   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74214   int arg2 ;
74215   int arg3 ;
74216   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
74217   bool arg5 ;
74218   int result;
74219
74220   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74221   arg2 = (int)jarg2;
74222   arg3 = (int)jarg3;
74223   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
74224   arg5 = jarg5 ? true : false;
74225   {
74226     try {
74227       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
74228     } catch (std::out_of_range& e) {
74229       {
74230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74231       };
74232     } catch (std::exception& e) {
74233       {
74234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74235       };
74236     } catch (Dali::DaliException e) {
74237       {
74238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74239       };
74240     } catch (...) {
74241       {
74242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74243       };
74244     }
74245   }
74246
74247   jresult = result;
74248   return jresult;
74249 }
74250
74251
74252 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
74253   float jresult ;
74254   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74255   float result;
74256
74257   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74258   {
74259     try {
74260       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
74261     } catch (std::out_of_range& e) {
74262       {
74263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74264       };
74265     } catch (std::exception& e) {
74266       {
74267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74268       };
74269     } catch (Dali::DaliException e) {
74270       {
74271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74272       };
74273     } catch (...) {
74274       {
74275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74276       };
74277     }
74278   }
74279
74280   jresult = result;
74281   return jresult;
74282 }
74283
74284
74285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
74286   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74287   Dali::Actor *arg2 = 0 ;
74288   int arg3 ;
74289   Dali::Vector3 *arg4 = 0 ;
74290   Dali::Actor *arg5 = 0 ;
74291
74292   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74293   arg2 = (Dali::Actor *)jarg2;
74294   if (!arg2) {
74295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
74296     return ;
74297   }
74298   arg3 = (int)jarg3;
74299   arg4 = (Dali::Vector3 *)jarg4;
74300   if (!arg4) {
74301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74302     return ;
74303   }
74304   arg5 = (Dali::Actor *)jarg5;
74305   if (!arg5) {
74306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
74307     return ;
74308   }
74309   {
74310     try {
74311       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
74312     } catch (std::out_of_range& e) {
74313       {
74314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74315       };
74316     } catch (std::exception& e) {
74317       {
74318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74319       };
74320     } catch (Dali::DaliException e) {
74321       {
74322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74323       };
74324     } catch (...) {
74325       {
74326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74327       };
74328     }
74329   }
74330
74331 }
74332
74333
74334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
74335   void * jresult ;
74336   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74337   int arg2 ;
74338   float arg3 ;
74339   Dali::Vector3 *arg4 = 0 ;
74340   Dali::Vector3 result;
74341
74342   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74343   arg2 = (int)jarg2;
74344   arg3 = (float)jarg3;
74345   arg4 = (Dali::Vector3 *)jarg4;
74346   if (!arg4) {
74347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74348     return 0;
74349   }
74350   {
74351     try {
74352       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
74353     } catch (std::out_of_range& e) {
74354       {
74355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74356       };
74357     } catch (std::exception& e) {
74358       {
74359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74360       };
74361     } catch (Dali::DaliException e) {
74362       {
74363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74364       };
74365     } catch (...) {
74366       {
74367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74368       };
74369     }
74370   }
74371
74372   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
74373   return jresult;
74374 }
74375
74376
74377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
74378   void * jresult ;
74379   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
74380   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
74381
74382   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
74383   {
74384     try {
74385       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
74386     } catch (std::out_of_range& e) {
74387       {
74388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74389       };
74390     } catch (std::exception& e) {
74391       {
74392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74393       };
74394     } catch (Dali::DaliException e) {
74395       {
74396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74397       };
74398     } catch (...) {
74399       {
74400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74401       };
74402     }
74403   }
74404
74405   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
74406   return jresult;
74407 }
74408
74409
74410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
74411   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74412
74413   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74414   {
74415     try {
74416       delete arg1;
74417     } catch (std::out_of_range& e) {
74418       {
74419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74420       };
74421     } catch (std::exception& e) {
74422       {
74423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74424       };
74425     } catch (Dali::DaliException e) {
74426       {
74427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74428       };
74429     } catch (...) {
74430       {
74431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74432       };
74433     }
74434   }
74435
74436 }
74437
74438
74439 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
74440   unsigned int jresult ;
74441   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74442   unsigned int result;
74443
74444   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74445   {
74446     try {
74447       result = (unsigned int)(arg1)->GetNumberOfItems();
74448     } catch (std::out_of_range& e) {
74449       {
74450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74451       };
74452     } catch (std::exception& e) {
74453       {
74454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74455       };
74456     } catch (Dali::DaliException e) {
74457       {
74458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74459       };
74460     } catch (...) {
74461       {
74462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74463       };
74464     }
74465   }
74466
74467   jresult = result;
74468   return jresult;
74469 }
74470
74471
74472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
74473   void * jresult ;
74474   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74475   unsigned int arg2 ;
74476   Dali::Actor result;
74477
74478   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74479   arg2 = (unsigned int)jarg2;
74480   {
74481     try {
74482       result = (arg1)->NewItem(arg2);
74483     } catch (std::out_of_range& e) {
74484       {
74485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74486       };
74487     } catch (std::exception& e) {
74488       {
74489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74490       };
74491     } catch (Dali::DaliException e) {
74492       {
74493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74494       };
74495     } catch (...) {
74496       {
74497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74498       };
74499     }
74500   }
74501
74502   jresult = new Dali::Actor((const Dali::Actor &)result);
74503   return jresult;
74504 }
74505
74506
74507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
74508   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74509   unsigned int arg2 ;
74510   Dali::Actor arg3 ;
74511   Dali::Actor *argp3 ;
74512
74513   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74514   arg2 = (unsigned int)jarg2;
74515   argp3 = (Dali::Actor *)jarg3;
74516   if (!argp3) {
74517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74518     return ;
74519   }
74520   arg3 = *argp3;
74521   {
74522     try {
74523       (arg1)->ItemReleased(arg2,arg3);
74524     } catch (std::out_of_range& e) {
74525       {
74526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74527       };
74528     } catch (std::exception& e) {
74529       {
74530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74531       };
74532     } catch (Dali::DaliException e) {
74533       {
74534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74535       };
74536     } catch (...) {
74537       {
74538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74539       };
74540     }
74541   }
74542
74543 }
74544
74545
74546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
74547   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74548   unsigned int arg2 ;
74549   Dali::Actor arg3 ;
74550   Dali::Actor *argp3 ;
74551
74552   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74553   arg2 = (unsigned int)jarg2;
74554   argp3 = (Dali::Actor *)jarg3;
74555   if (!argp3) {
74556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74557     return ;
74558   }
74559   arg3 = *argp3;
74560   {
74561     try {
74562       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
74563     } catch (std::out_of_range& e) {
74564       {
74565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74566       };
74567     } catch (std::exception& e) {
74568       {
74569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74570       };
74571     } catch (Dali::DaliException e) {
74572       {
74573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74574       };
74575     } catch (...) {
74576       {
74577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74578       };
74579     }
74580   }
74581
74582 }
74583
74584
74585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
74586   void * jresult ;
74587   Dali::Toolkit::ItemFactory *result = 0 ;
74588
74589   {
74590     try {
74591       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
74592     } catch (std::out_of_range& e) {
74593       {
74594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74595       };
74596     } catch (std::exception& e) {
74597       {
74598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74599       };
74600     } catch (Dali::DaliException e) {
74601       {
74602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74603       };
74604     } catch (...) {
74605       {
74606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74607       };
74608     }
74609   }
74610
74611   jresult = (void *)result;
74612   return jresult;
74613 }
74614
74615
74616 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) {
74617   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
74618   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
74619   if (director) {
74620     director->swig_connect_director(callback0, callback1, callback2);
74621   }
74622 }
74623
74624
74625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
74626   int jresult ;
74627   int result;
74628
74629   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
74630   jresult = (int)result;
74631   return jresult;
74632 }
74633
74634
74635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
74636   int jresult ;
74637   int result;
74638
74639   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
74640   jresult = (int)result;
74641   return jresult;
74642 }
74643
74644
74645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
74646   int jresult ;
74647   int result;
74648
74649   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
74650   jresult = (int)result;
74651   return jresult;
74652 }
74653
74654
74655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
74656   int jresult ;
74657   int result;
74658
74659   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
74660   jresult = (int)result;
74661   return jresult;
74662 }
74663
74664
74665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
74666   int jresult ;
74667   int result;
74668
74669   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
74670   jresult = (int)result;
74671   return jresult;
74672 }
74673
74674
74675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
74676   int jresult ;
74677   int result;
74678
74679   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
74680   jresult = (int)result;
74681   return jresult;
74682 }
74683
74684
74685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
74686   int jresult ;
74687   int result;
74688
74689   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
74690   jresult = (int)result;
74691   return jresult;
74692 }
74693
74694
74695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
74696   int jresult ;
74697   int result;
74698
74699   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
74700   jresult = (int)result;
74701   return jresult;
74702 }
74703
74704
74705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
74706   int jresult ;
74707   int result;
74708
74709   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
74710   jresult = (int)result;
74711   return jresult;
74712 }
74713
74714
74715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
74716   int jresult ;
74717   int result;
74718
74719   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
74720   jresult = (int)result;
74721   return jresult;
74722 }
74723
74724
74725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
74726   int jresult ;
74727   int result;
74728
74729   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
74730   jresult = (int)result;
74731   return jresult;
74732 }
74733
74734
74735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
74736   void * jresult ;
74737   Dali::Toolkit::ItemView::Property *result = 0 ;
74738
74739   {
74740     try {
74741       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
74742     } catch (std::out_of_range& e) {
74743       {
74744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74745       };
74746     } catch (std::exception& e) {
74747       {
74748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74749       };
74750     } catch (Dali::DaliException e) {
74751       {
74752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74753       };
74754     } catch (...) {
74755       {
74756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74757       };
74758     }
74759   }
74760
74761   jresult = (void *)result;
74762   return jresult;
74763 }
74764
74765
74766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
74767   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
74768
74769   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
74770   {
74771     try {
74772       delete arg1;
74773     } catch (std::out_of_range& e) {
74774       {
74775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74776       };
74777     } catch (std::exception& e) {
74778       {
74779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74780       };
74781     } catch (Dali::DaliException e) {
74782       {
74783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74784       };
74785     } catch (...) {
74786       {
74787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74788       };
74789     }
74790   }
74791
74792 }
74793
74794
74795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
74796   void * jresult ;
74797   Dali::Toolkit::ItemView *result = 0 ;
74798
74799   {
74800     try {
74801       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
74802     } catch (std::out_of_range& e) {
74803       {
74804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74805       };
74806     } catch (std::exception& e) {
74807       {
74808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74809       };
74810     } catch (Dali::DaliException e) {
74811       {
74812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74813       };
74814     } catch (...) {
74815       {
74816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74817       };
74818     }
74819   }
74820
74821   jresult = (void *)result;
74822   return jresult;
74823 }
74824
74825
74826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
74827   void * jresult ;
74828   Dali::Toolkit::ItemView *arg1 = 0 ;
74829   Dali::Toolkit::ItemView *result = 0 ;
74830
74831   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74832   if (!arg1) {
74833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
74834     return 0;
74835   }
74836   {
74837     try {
74838       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
74839     } catch (std::out_of_range& e) {
74840       {
74841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74842       };
74843     } catch (std::exception& e) {
74844       {
74845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74846       };
74847     } catch (Dali::DaliException e) {
74848       {
74849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74850       };
74851     } catch (...) {
74852       {
74853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74854       };
74855     }
74856   }
74857
74858   jresult = (void *)result;
74859   return jresult;
74860 }
74861
74862
74863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
74864   void * jresult ;
74865   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74866   Dali::Toolkit::ItemView *arg2 = 0 ;
74867   Dali::Toolkit::ItemView *result = 0 ;
74868
74869   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74870   arg2 = (Dali::Toolkit::ItemView *)jarg2;
74871   if (!arg2) {
74872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
74873     return 0;
74874   }
74875   {
74876     try {
74877       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
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 = (void *)result;
74898   return jresult;
74899 }
74900
74901
74902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
74903   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74904
74905   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74906   {
74907     try {
74908       delete arg1;
74909     } catch (std::out_of_range& e) {
74910       {
74911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74912       };
74913     } catch (std::exception& e) {
74914       {
74915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74916       };
74917     } catch (Dali::DaliException e) {
74918       {
74919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74920       };
74921     } catch (...) {
74922       {
74923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74924       };
74925     }
74926   }
74927
74928 }
74929
74930
74931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
74932   void * jresult ;
74933   Dali::Toolkit::ItemFactory *arg1 = 0 ;
74934   Dali::Toolkit::ItemView result;
74935
74936   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74937   if (!arg1) {
74938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
74939     return 0;
74940   }
74941   {
74942     try {
74943       result = Dali::Toolkit::ItemView::New(*arg1);
74944     } catch (std::out_of_range& e) {
74945       {
74946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74947       };
74948     } catch (std::exception& e) {
74949       {
74950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74951       };
74952     } catch (Dali::DaliException e) {
74953       {
74954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74955       };
74956     } catch (...) {
74957       {
74958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74959       };
74960     }
74961   }
74962
74963   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
74964   return jresult;
74965 }
74966
74967
74968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
74969   void * jresult ;
74970   Dali::BaseHandle arg1 ;
74971   Dali::BaseHandle *argp1 ;
74972   Dali::Toolkit::ItemView result;
74973
74974   argp1 = (Dali::BaseHandle *)jarg1;
74975   if (!argp1) {
74976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74977     return 0;
74978   }
74979   arg1 = *argp1;
74980   {
74981     try {
74982       result = Dali::Toolkit::ItemView::DownCast(arg1);
74983     } catch (std::out_of_range& e) {
74984       {
74985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74986       };
74987     } catch (std::exception& e) {
74988       {
74989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74990       };
74991     } catch (Dali::DaliException e) {
74992       {
74993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74994       };
74995     } catch (...) {
74996       {
74997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74998       };
74999     }
75000   }
75001
75002   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
75003   return jresult;
75004 }
75005
75006
75007 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
75008   unsigned int jresult ;
75009   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75010   unsigned int result;
75011
75012   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75013   {
75014     try {
75015       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
75016     } catch (std::out_of_range& e) {
75017       {
75018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75019       };
75020     } catch (std::exception& e) {
75021       {
75022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75023       };
75024     } catch (Dali::DaliException e) {
75025       {
75026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75027       };
75028     } catch (...) {
75029       {
75030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75031       };
75032     }
75033   }
75034
75035   jresult = result;
75036   return jresult;
75037 }
75038
75039
75040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
75041   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75042   Dali::Toolkit::ItemLayout *arg2 = 0 ;
75043
75044   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75045   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
75046   if (!arg2) {
75047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
75048     return ;
75049   }
75050   {
75051     try {
75052       (arg1)->AddLayout(*arg2);
75053     } catch (std::out_of_range& e) {
75054       {
75055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75056       };
75057     } catch (std::exception& e) {
75058       {
75059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75060       };
75061     } catch (Dali::DaliException e) {
75062       {
75063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75064       };
75065     } catch (...) {
75066       {
75067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75068       };
75069     }
75070   }
75071
75072 }
75073
75074
75075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
75076   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75077   unsigned int arg2 ;
75078
75079   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75080   arg2 = (unsigned int)jarg2;
75081   {
75082     try {
75083       (arg1)->RemoveLayout(arg2);
75084     } catch (std::out_of_range& e) {
75085       {
75086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75087       };
75088     } catch (std::exception& e) {
75089       {
75090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75091       };
75092     } catch (Dali::DaliException e) {
75093       {
75094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75095       };
75096     } catch (...) {
75097       {
75098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75099       };
75100     }
75101   }
75102
75103 }
75104
75105
75106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
75107   void * jresult ;
75108   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75109   unsigned int arg2 ;
75110   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75111
75112   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75113   arg2 = (unsigned int)jarg2;
75114   {
75115     try {
75116       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
75117     } catch (std::out_of_range& e) {
75118       {
75119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75120       };
75121     } catch (std::exception& e) {
75122       {
75123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75124       };
75125     } catch (Dali::DaliException e) {
75126       {
75127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75128       };
75129     } catch (...) {
75130       {
75131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75132       };
75133     }
75134   }
75135
75136   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75137   return jresult;
75138 }
75139
75140
75141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
75142   void * jresult ;
75143   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75144   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75145
75146   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75147   {
75148     try {
75149       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
75150     } catch (std::out_of_range& e) {
75151       {
75152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75153       };
75154     } catch (std::exception& e) {
75155       {
75156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75157       };
75158     } catch (Dali::DaliException e) {
75159       {
75160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75161       };
75162     } catch (...) {
75163       {
75164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75165       };
75166     }
75167   }
75168
75169   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75170   return jresult;
75171 }
75172
75173
75174 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
75175   float jresult ;
75176   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75177   Dali::Toolkit::ItemId arg2 ;
75178   float result;
75179
75180   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75181   arg2 = (Dali::Toolkit::ItemId)jarg2;
75182   {
75183     try {
75184       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
75185     } catch (std::out_of_range& e) {
75186       {
75187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75188       };
75189     } catch (std::exception& e) {
75190       {
75191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75192       };
75193     } catch (Dali::DaliException e) {
75194       {
75195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75196       };
75197     } catch (...) {
75198       {
75199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75200       };
75201     }
75202   }
75203
75204   jresult = result;
75205   return jresult;
75206 }
75207
75208
75209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
75210   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75211   unsigned int arg2 ;
75212   Dali::Vector3 arg3 ;
75213   float arg4 ;
75214   Dali::Vector3 *argp3 ;
75215
75216   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75217   arg2 = (unsigned int)jarg2;
75218   argp3 = (Dali::Vector3 *)jarg3;
75219   if (!argp3) {
75220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75221     return ;
75222   }
75223   arg3 = *argp3;
75224   arg4 = (float)jarg4;
75225   {
75226     try {
75227       (arg1)->ActivateLayout(arg2,arg3,arg4);
75228     } catch (std::out_of_range& e) {
75229       {
75230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75231       };
75232     } catch (std::exception& e) {
75233       {
75234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75235       };
75236     } catch (Dali::DaliException e) {
75237       {
75238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75239       };
75240     } catch (...) {
75241       {
75242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75243       };
75244     }
75245   }
75246
75247 }
75248
75249
75250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
75251   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75252
75253   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75254   {
75255     try {
75256       (arg1)->DeactivateCurrentLayout();
75257     } catch (std::out_of_range& e) {
75258       {
75259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75260       };
75261     } catch (std::exception& e) {
75262       {
75263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75264       };
75265     } catch (Dali::DaliException e) {
75266       {
75267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75268       };
75269     } catch (...) {
75270       {
75271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75272       };
75273     }
75274   }
75275
75276 }
75277
75278
75279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
75280   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75281   float arg2 ;
75282
75283   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75284   arg2 = (float)jarg2;
75285   {
75286     try {
75287       (arg1)->SetMinimumSwipeSpeed(arg2);
75288     } catch (std::out_of_range& e) {
75289       {
75290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75291       };
75292     } catch (std::exception& e) {
75293       {
75294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75295       };
75296     } catch (Dali::DaliException e) {
75297       {
75298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75299       };
75300     } catch (...) {
75301       {
75302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75303       };
75304     }
75305   }
75306
75307 }
75308
75309
75310 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
75311   float jresult ;
75312   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75313   float result;
75314
75315   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75316   {
75317     try {
75318       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
75319     } catch (std::out_of_range& e) {
75320       {
75321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75322       };
75323     } catch (std::exception& e) {
75324       {
75325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75326       };
75327     } catch (Dali::DaliException e) {
75328       {
75329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75330       };
75331     } catch (...) {
75332       {
75333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75334       };
75335     }
75336   }
75337
75338   jresult = result;
75339   return jresult;
75340 }
75341
75342
75343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
75344   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75345   float arg2 ;
75346
75347   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75348   arg2 = (float)jarg2;
75349   {
75350     try {
75351       (arg1)->SetMinimumSwipeDistance(arg2);
75352     } catch (std::out_of_range& e) {
75353       {
75354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75355       };
75356     } catch (std::exception& e) {
75357       {
75358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75359       };
75360     } catch (Dali::DaliException e) {
75361       {
75362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75363       };
75364     } catch (...) {
75365       {
75366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75367       };
75368     }
75369   }
75370
75371 }
75372
75373
75374 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
75375   float jresult ;
75376   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75377   float result;
75378
75379   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75380   {
75381     try {
75382       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
75383     } catch (std::out_of_range& e) {
75384       {
75385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75386       };
75387     } catch (std::exception& e) {
75388       {
75389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75390       };
75391     } catch (Dali::DaliException e) {
75392       {
75393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75394       };
75395     } catch (...) {
75396       {
75397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75398       };
75399     }
75400   }
75401
75402   jresult = result;
75403   return jresult;
75404 }
75405
75406
75407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
75408   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75409   float arg2 ;
75410
75411   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75412   arg2 = (float)jarg2;
75413   {
75414     try {
75415       (arg1)->SetWheelScrollDistanceStep(arg2);
75416     } catch (std::out_of_range& e) {
75417       {
75418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75419       };
75420     } catch (std::exception& e) {
75421       {
75422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75423       };
75424     } catch (Dali::DaliException e) {
75425       {
75426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75427       };
75428     } catch (...) {
75429       {
75430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75431       };
75432     }
75433   }
75434
75435 }
75436
75437
75438 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
75439   float jresult ;
75440   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75441   float result;
75442
75443   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75444   {
75445     try {
75446       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
75447     } catch (std::out_of_range& e) {
75448       {
75449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75450       };
75451     } catch (std::exception& e) {
75452       {
75453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75454       };
75455     } catch (Dali::DaliException e) {
75456       {
75457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75458       };
75459     } catch (...) {
75460       {
75461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75462       };
75463     }
75464   }
75465
75466   jresult = result;
75467   return jresult;
75468 }
75469
75470
75471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
75472   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75473   bool arg2 ;
75474
75475   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75476   arg2 = jarg2 ? true : false;
75477   {
75478     try {
75479       (arg1)->SetAnchoring(arg2);
75480     } catch (std::out_of_range& e) {
75481       {
75482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75483       };
75484     } catch (std::exception& e) {
75485       {
75486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75487       };
75488     } catch (Dali::DaliException e) {
75489       {
75490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75491       };
75492     } catch (...) {
75493       {
75494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75495       };
75496     }
75497   }
75498
75499 }
75500
75501 //// ========================= end of part 3 =============================
75502
75503 //// ========================== start part 4 ===============================
75504
75505
75506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
75507   unsigned int jresult ;
75508   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75509   bool result;
75510
75511   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75512   {
75513     try {
75514       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
75515     } catch (std::out_of_range& e) {
75516       {
75517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75518       };
75519     } catch (std::exception& e) {
75520       {
75521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75522       };
75523     } catch (Dali::DaliException e) {
75524       {
75525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75526       };
75527     } catch (...) {
75528       {
75529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75530       };
75531     }
75532   }
75533
75534   jresult = result;
75535   return jresult;
75536 }
75537
75538
75539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
75540   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75541   float arg2 ;
75542
75543   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75544   arg2 = (float)jarg2;
75545   {
75546     try {
75547       (arg1)->SetAnchoringDuration(arg2);
75548     } catch (std::out_of_range& e) {
75549       {
75550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75551       };
75552     } catch (std::exception& e) {
75553       {
75554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75555       };
75556     } catch (Dali::DaliException e) {
75557       {
75558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75559       };
75560     } catch (...) {
75561       {
75562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75563       };
75564     }
75565   }
75566
75567 }
75568
75569
75570 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
75571   float jresult ;
75572   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75573   float result;
75574
75575   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75576   {
75577     try {
75578       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
75579     } catch (std::out_of_range& e) {
75580       {
75581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75582       };
75583     } catch (std::exception& e) {
75584       {
75585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75586       };
75587     } catch (Dali::DaliException e) {
75588       {
75589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75590       };
75591     } catch (...) {
75592       {
75593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75594       };
75595     }
75596   }
75597
75598   jresult = result;
75599   return jresult;
75600 }
75601
75602
75603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
75604   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75605   Dali::Toolkit::ItemId arg2 ;
75606   float arg3 ;
75607
75608   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75609   arg2 = (Dali::Toolkit::ItemId)jarg2;
75610   arg3 = (float)jarg3;
75611   {
75612     try {
75613       (arg1)->ScrollToItem(arg2,arg3);
75614     } catch (std::out_of_range& e) {
75615       {
75616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75617       };
75618     } catch (std::exception& e) {
75619       {
75620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75621       };
75622     } catch (Dali::DaliException e) {
75623       {
75624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75625       };
75626     } catch (...) {
75627       {
75628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75629       };
75630     }
75631   }
75632
75633 }
75634
75635
75636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
75637   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75638   float arg2 ;
75639
75640   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75641   arg2 = (float)jarg2;
75642   {
75643     try {
75644       (arg1)->SetRefreshInterval(arg2);
75645     } catch (std::out_of_range& e) {
75646       {
75647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75648       };
75649     } catch (std::exception& e) {
75650       {
75651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75652       };
75653     } catch (Dali::DaliException e) {
75654       {
75655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75656       };
75657     } catch (...) {
75658       {
75659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75660       };
75661     }
75662   }
75663
75664 }
75665
75666
75667 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
75668   float jresult ;
75669   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75670   float result;
75671
75672   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75673   {
75674     try {
75675       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
75676     } catch (std::out_of_range& e) {
75677       {
75678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75679       };
75680     } catch (std::exception& e) {
75681       {
75682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75683       };
75684     } catch (Dali::DaliException e) {
75685       {
75686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75687       };
75688     } catch (...) {
75689       {
75690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75691       };
75692     }
75693   }
75694
75695   jresult = result;
75696   return jresult;
75697 }
75698
75699
75700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
75701   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75702
75703   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75704   {
75705     try {
75706       (arg1)->Refresh();
75707     } catch (std::out_of_range& e) {
75708       {
75709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75710       };
75711     } catch (std::exception& e) {
75712       {
75713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75714       };
75715     } catch (Dali::DaliException e) {
75716       {
75717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75718       };
75719     } catch (...) {
75720       {
75721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75722       };
75723     }
75724   }
75725
75726 }
75727
75728
75729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
75730   void * jresult ;
75731   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75732   Dali::Toolkit::ItemId arg2 ;
75733   Dali::Actor result;
75734
75735   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75736   arg2 = (Dali::Toolkit::ItemId)jarg2;
75737   {
75738     try {
75739       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
75740     } catch (std::out_of_range& e) {
75741       {
75742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75743       };
75744     } catch (std::exception& e) {
75745       {
75746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75747       };
75748     } catch (Dali::DaliException e) {
75749       {
75750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75751       };
75752     } catch (...) {
75753       {
75754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75755       };
75756     }
75757   }
75758
75759   jresult = new Dali::Actor((const Dali::Actor &)result);
75760   return jresult;
75761 }
75762
75763
75764 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
75765   unsigned int jresult ;
75766   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75767   Dali::Actor arg2 ;
75768   Dali::Actor *argp2 ;
75769   Dali::Toolkit::ItemId result;
75770
75771   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75772   argp2 = (Dali::Actor *)jarg2;
75773   if (!argp2) {
75774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75775     return 0;
75776   }
75777   arg2 = *argp2;
75778   {
75779     try {
75780       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
75781     } catch (std::out_of_range& e) {
75782       {
75783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75784       };
75785     } catch (std::exception& e) {
75786       {
75787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75788       };
75789     } catch (Dali::DaliException e) {
75790       {
75791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75792       };
75793     } catch (...) {
75794       {
75795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75796       };
75797     }
75798   }
75799
75800   jresult = result;
75801   return jresult;
75802 }
75803
75804
75805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
75806   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75807   Dali::Toolkit::Item arg2 ;
75808   float arg3 ;
75809   Dali::Toolkit::Item *argp2 ;
75810
75811   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75812   argp2 = (Dali::Toolkit::Item *)jarg2;
75813   if (!argp2) {
75814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
75815     return ;
75816   }
75817   arg2 = *argp2;
75818   arg3 = (float)jarg3;
75819   {
75820     try {
75821       (arg1)->InsertItem(arg2,arg3);
75822     } catch (std::out_of_range& e) {
75823       {
75824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75825       };
75826     } catch (std::exception& e) {
75827       {
75828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75829       };
75830     } catch (Dali::DaliException e) {
75831       {
75832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75833       };
75834     } catch (...) {
75835       {
75836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75837       };
75838     }
75839   }
75840
75841 }
75842
75843
75844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
75845   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75846   Dali::Toolkit::ItemContainer *arg2 = 0 ;
75847   float arg3 ;
75848
75849   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75850   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
75851   if (!arg2) {
75852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
75853     return ;
75854   }
75855   arg3 = (float)jarg3;
75856   {
75857     try {
75858       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
75859     } catch (std::out_of_range& e) {
75860       {
75861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75862       };
75863     } catch (std::exception& e) {
75864       {
75865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75866       };
75867     } catch (Dali::DaliException e) {
75868       {
75869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75870       };
75871     } catch (...) {
75872       {
75873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75874       };
75875     }
75876   }
75877
75878 }
75879
75880
75881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
75882   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75883   Dali::Toolkit::ItemId arg2 ;
75884   float arg3 ;
75885
75886   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75887   arg2 = (Dali::Toolkit::ItemId)jarg2;
75888   arg3 = (float)jarg3;
75889   {
75890     try {
75891       (arg1)->RemoveItem(arg2,arg3);
75892     } catch (std::out_of_range& e) {
75893       {
75894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75895       };
75896     } catch (std::exception& e) {
75897       {
75898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75899       };
75900     } catch (Dali::DaliException e) {
75901       {
75902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75903       };
75904     } catch (...) {
75905       {
75906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75907       };
75908     }
75909   }
75910
75911 }
75912
75913
75914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
75915   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75916   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
75917   float arg3 ;
75918
75919   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75920   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
75921   if (!arg2) {
75922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
75923     return ;
75924   }
75925   arg3 = (float)jarg3;
75926   {
75927     try {
75928       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
75929     } catch (std::out_of_range& e) {
75930       {
75931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75932       };
75933     } catch (std::exception& e) {
75934       {
75935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75936       };
75937     } catch (Dali::DaliException e) {
75938       {
75939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75940       };
75941     } catch (...) {
75942       {
75943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75944       };
75945     }
75946   }
75947
75948 }
75949
75950
75951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
75952   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75953   Dali::Toolkit::Item arg2 ;
75954   float arg3 ;
75955   Dali::Toolkit::Item *argp2 ;
75956
75957   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75958   argp2 = (Dali::Toolkit::Item *)jarg2;
75959   if (!argp2) {
75960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
75961     return ;
75962   }
75963   arg2 = *argp2;
75964   arg3 = (float)jarg3;
75965   {
75966     try {
75967       (arg1)->ReplaceItem(arg2,arg3);
75968     } catch (std::out_of_range& e) {
75969       {
75970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75971       };
75972     } catch (std::exception& e) {
75973       {
75974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75975       };
75976     } catch (Dali::DaliException e) {
75977       {
75978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75979       };
75980     } catch (...) {
75981       {
75982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75983       };
75984     }
75985   }
75986
75987 }
75988
75989
75990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
75991   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75992   Dali::Toolkit::ItemContainer *arg2 = 0 ;
75993   float arg3 ;
75994
75995   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75996   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
75997   if (!arg2) {
75998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
75999     return ;
76000   }
76001   arg3 = (float)jarg3;
76002   {
76003     try {
76004       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
76005     } catch (std::out_of_range& e) {
76006       {
76007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76008       };
76009     } catch (std::exception& e) {
76010       {
76011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76012       };
76013     } catch (Dali::DaliException e) {
76014       {
76015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76016       };
76017     } catch (...) {
76018       {
76019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76020       };
76021     }
76022   }
76023
76024 }
76025
76026
76027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
76028   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76029   Dali::Vector3 *arg2 = 0 ;
76030
76031   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76032   arg2 = (Dali::Vector3 *)jarg2;
76033   if (!arg2) {
76034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76035     return ;
76036   }
76037   {
76038     try {
76039       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
76040     } catch (std::out_of_range& e) {
76041       {
76042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76043       };
76044     } catch (std::exception& e) {
76045       {
76046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76047       };
76048     } catch (Dali::DaliException e) {
76049       {
76050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76051       };
76052     } catch (...) {
76053       {
76054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76055       };
76056     }
76057   }
76058
76059 }
76060
76061
76062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
76063   void * jresult ;
76064   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76065   Dali::Vector3 result;
76066
76067   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76068   {
76069     try {
76070       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
76071     } catch (std::out_of_range& e) {
76072       {
76073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76074       };
76075     } catch (std::exception& e) {
76076       {
76077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76078       };
76079     } catch (Dali::DaliException e) {
76080       {
76081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76082       };
76083     } catch (...) {
76084       {
76085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76086       };
76087     }
76088   }
76089
76090   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
76091   return jresult;
76092 }
76093
76094
76095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
76096   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76097   Dali::Vector3 *arg2 = 0 ;
76098
76099   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76100   arg2 = (Dali::Vector3 *)jarg2;
76101   if (!arg2) {
76102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76103     return ;
76104   }
76105   {
76106     try {
76107       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
76108     } catch (std::out_of_range& e) {
76109       {
76110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76111       };
76112     } catch (std::exception& e) {
76113       {
76114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76115       };
76116     } catch (Dali::DaliException e) {
76117       {
76118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76119       };
76120     } catch (...) {
76121       {
76122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76123       };
76124     }
76125   }
76126
76127 }
76128
76129
76130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
76131   void * jresult ;
76132   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76133   Dali::Vector3 result;
76134
76135   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76136   {
76137     try {
76138       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
76139     } catch (std::out_of_range& e) {
76140       {
76141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76142       };
76143     } catch (std::exception& e) {
76144       {
76145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76146       };
76147     } catch (Dali::DaliException e) {
76148       {
76149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76150       };
76151     } catch (...) {
76152       {
76153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76154       };
76155     }
76156   }
76157
76158   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
76159   return jresult;
76160 }
76161
76162
76163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
76164   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76165   Dali::Toolkit::ItemRange *arg2 = 0 ;
76166
76167   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76168   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
76169   if (!arg2) {
76170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
76171     return ;
76172   }
76173   {
76174     try {
76175       (arg1)->GetItemsRange(*arg2);
76176     } catch (std::out_of_range& e) {
76177       {
76178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76179       };
76180     } catch (std::exception& e) {
76181       {
76182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76183       };
76184     } catch (Dali::DaliException e) {
76185       {
76186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76187       };
76188     } catch (...) {
76189       {
76190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76191       };
76192     }
76193   }
76194
76195 }
76196
76197
76198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
76199   void * jresult ;
76200   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76201   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
76202
76203   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76204   {
76205     try {
76206       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
76207     } catch (std::out_of_range& e) {
76208       {
76209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76210       };
76211     } catch (std::exception& e) {
76212       {
76213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76214       };
76215     } catch (Dali::DaliException e) {
76216       {
76217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76218       };
76219     } catch (...) {
76220       {
76221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76222       };
76223     }
76224   }
76225
76226   jresult = (void *)result;
76227   return jresult;
76228 }
76229
76230
76231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
76232   Dali::Vector3 *arg1 = 0 ;
76233   PropertyInputContainer *arg2 = 0 ;
76234
76235   arg1 = (Dali::Vector3 *)jarg1;
76236   if (!arg1) {
76237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
76238     return ;
76239   }
76240   arg2 = (PropertyInputContainer *)jarg2;
76241   if (!arg2) {
76242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
76243     return ;
76244   }
76245   {
76246     try {
76247       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
76248     } catch (std::out_of_range& e) {
76249       {
76250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76251       };
76252     } catch (std::exception& e) {
76253       {
76254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76255       };
76256     } catch (Dali::DaliException e) {
76257       {
76258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76259       };
76260     } catch (...) {
76261       {
76262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76263       };
76264     }
76265   }
76266
76267 }
76268
76269
76270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
76271   Dali::Vector3 *arg1 = 0 ;
76272   PropertyInputContainer *arg2 = 0 ;
76273
76274   arg1 = (Dali::Vector3 *)jarg1;
76275   if (!arg1) {
76276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
76277     return ;
76278   }
76279   arg2 = (PropertyInputContainer *)jarg2;
76280   if (!arg2) {
76281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
76282     return ;
76283   }
76284   {
76285     try {
76286       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
76287     } catch (std::out_of_range& e) {
76288       {
76289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76290       };
76291     } catch (std::exception& e) {
76292       {
76293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76294       };
76295     } catch (Dali::DaliException e) {
76296       {
76297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76298       };
76299     } catch (...) {
76300       {
76301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76302       };
76303     }
76304   }
76305
76306 }
76307
76308
76309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
76310   void * jresult ;
76311   Dali::Toolkit::ScrollViewEffect *result = 0 ;
76312
76313   {
76314     try {
76315       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
76316     } catch (std::out_of_range& e) {
76317       {
76318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76319       };
76320     } catch (std::exception& e) {
76321       {
76322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76323       };
76324     } catch (Dali::DaliException e) {
76325       {
76326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76327       };
76328     } catch (...) {
76329       {
76330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76331       };
76332     }
76333   }
76334
76335   jresult = (void *)result;
76336   return jresult;
76337 }
76338
76339
76340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
76341   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
76342
76343   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
76344   {
76345     try {
76346       delete arg1;
76347     } catch (std::out_of_range& e) {
76348       {
76349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76350       };
76351     } catch (std::exception& e) {
76352       {
76353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76354       };
76355     } catch (Dali::DaliException e) {
76356       {
76357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76358       };
76359     } catch (...) {
76360       {
76361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76362       };
76363     }
76364   }
76365
76366 }
76367
76368
76369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
76370   void * jresult ;
76371   Dali::Path arg1 ;
76372   Dali::Vector3 *arg2 = 0 ;
76373   Dali::Property::Index arg3 ;
76374   Dali::Vector3 *arg4 = 0 ;
76375   unsigned int arg5 ;
76376   Dali::Path *argp1 ;
76377   Dali::Toolkit::ScrollViewPagePathEffect result;
76378
76379   argp1 = (Dali::Path *)jarg1;
76380   if (!argp1) {
76381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
76382     return 0;
76383   }
76384   arg1 = *argp1;
76385   arg2 = (Dali::Vector3 *)jarg2;
76386   if (!arg2) {
76387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76388     return 0;
76389   }
76390   arg3 = (Dali::Property::Index)jarg3;
76391   arg4 = (Dali::Vector3 *)jarg4;
76392   if (!arg4) {
76393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76394     return 0;
76395   }
76396   arg5 = (unsigned int)jarg5;
76397   {
76398     try {
76399       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
76400     } catch (std::out_of_range& e) {
76401       {
76402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76403       };
76404     } catch (std::exception& e) {
76405       {
76406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76407       };
76408     } catch (Dali::DaliException e) {
76409       {
76410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76411       };
76412     } catch (...) {
76413       {
76414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76415       };
76416     }
76417   }
76418
76419   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
76420   return jresult;
76421 }
76422
76423
76424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
76425   void * jresult ;
76426   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
76427
76428   {
76429     try {
76430       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
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 = (void *)result;
76451   return jresult;
76452 }
76453
76454
76455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
76456   void * jresult ;
76457   Dali::BaseHandle arg1 ;
76458   Dali::BaseHandle *argp1 ;
76459   Dali::Toolkit::ScrollViewPagePathEffect result;
76460
76461   argp1 = (Dali::BaseHandle *)jarg1;
76462   if (!argp1) {
76463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76464     return 0;
76465   }
76466   arg1 = *argp1;
76467   {
76468     try {
76469       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
76470     } catch (std::out_of_range& e) {
76471       {
76472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76473       };
76474     } catch (std::exception& e) {
76475       {
76476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76477       };
76478     } catch (Dali::DaliException e) {
76479       {
76480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76481       };
76482     } catch (...) {
76483       {
76484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76485       };
76486     }
76487   }
76488
76489   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
76490   return jresult;
76491 }
76492
76493
76494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
76495   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
76496   Dali::Actor arg2 ;
76497   unsigned int arg3 ;
76498   Dali::Actor *argp2 ;
76499
76500   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
76501   argp2 = (Dali::Actor *)jarg2;
76502   if (!argp2) {
76503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76504     return ;
76505   }
76506   arg2 = *argp2;
76507   arg3 = (unsigned int)jarg3;
76508   {
76509     try {
76510       (arg1)->ApplyToPage(arg2,arg3);
76511     } catch (std::out_of_range& e) {
76512       {
76513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76514       };
76515     } catch (std::exception& e) {
76516       {
76517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76518       };
76519     } catch (Dali::DaliException e) {
76520       {
76521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76522       };
76523     } catch (...) {
76524       {
76525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76526       };
76527     }
76528   }
76529
76530 }
76531
76532
76533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
76534   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
76535
76536   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
76537   {
76538     try {
76539       delete arg1;
76540     } catch (std::out_of_range& e) {
76541       {
76542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76543       };
76544     } catch (std::exception& e) {
76545       {
76546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76547       };
76548     } catch (Dali::DaliException e) {
76549       {
76550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76551       };
76552     } catch (...) {
76553       {
76554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76555       };
76556     }
76557   }
76558
76559 }
76560
76561
76562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
76563   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76564   Dali::Toolkit::ClampState arg2 ;
76565
76566   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76567   arg2 = (Dali::Toolkit::ClampState)jarg2;
76568   if (arg1) (arg1)->x = arg2;
76569 }
76570
76571
76572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
76573   int jresult ;
76574   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76575   Dali::Toolkit::ClampState result;
76576
76577   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76578   result = (Dali::Toolkit::ClampState) ((arg1)->x);
76579   jresult = (int)result;
76580   return jresult;
76581 }
76582
76583
76584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
76585   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76586   Dali::Toolkit::ClampState arg2 ;
76587
76588   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76589   arg2 = (Dali::Toolkit::ClampState)jarg2;
76590   if (arg1) (arg1)->y = arg2;
76591 }
76592
76593
76594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
76595   int jresult ;
76596   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76597   Dali::Toolkit::ClampState result;
76598
76599   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76600   result = (Dali::Toolkit::ClampState) ((arg1)->y);
76601   jresult = (int)result;
76602   return jresult;
76603 }
76604
76605
76606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
76607   void * jresult ;
76608   Dali::Toolkit::ClampState2D *result = 0 ;
76609
76610   {
76611     try {
76612       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
76613     } catch (std::out_of_range& e) {
76614       {
76615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76616       };
76617     } catch (std::exception& e) {
76618       {
76619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76620       };
76621     } catch (Dali::DaliException e) {
76622       {
76623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76624       };
76625     } catch (...) {
76626       {
76627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76628       };
76629     }
76630   }
76631
76632   jresult = (void *)result;
76633   return jresult;
76634 }
76635
76636
76637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
76638   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76639
76640   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76641   {
76642     try {
76643       delete arg1;
76644     } catch (std::out_of_range& e) {
76645       {
76646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76647       };
76648     } catch (std::exception& e) {
76649       {
76650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76651       };
76652     } catch (Dali::DaliException e) {
76653       {
76654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76655       };
76656     } catch (...) {
76657       {
76658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76659       };
76660     }
76661   }
76662
76663 }
76664
76665
76666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
76667   void * jresult ;
76668   float arg1 ;
76669   float arg2 ;
76670   bool arg3 ;
76671   Dali::Toolkit::RulerDomain *result = 0 ;
76672
76673   arg1 = (float)jarg1;
76674   arg2 = (float)jarg2;
76675   arg3 = jarg3 ? true : false;
76676   {
76677     try {
76678       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
76679     } catch (std::out_of_range& e) {
76680       {
76681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76682       };
76683     } catch (std::exception& e) {
76684       {
76685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76686       };
76687     } catch (Dali::DaliException e) {
76688       {
76689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76690       };
76691     } catch (...) {
76692       {
76693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76694       };
76695     }
76696   }
76697
76698   jresult = (void *)result;
76699   return jresult;
76700 }
76701
76702
76703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
76704   void * jresult ;
76705   float arg1 ;
76706   float arg2 ;
76707   Dali::Toolkit::RulerDomain *result = 0 ;
76708
76709   arg1 = (float)jarg1;
76710   arg2 = (float)jarg2;
76711   {
76712     try {
76713       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
76714     } catch (std::out_of_range& e) {
76715       {
76716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76717       };
76718     } catch (std::exception& e) {
76719       {
76720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76721       };
76722     } catch (Dali::DaliException e) {
76723       {
76724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76725       };
76726     } catch (...) {
76727       {
76728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76729       };
76730     }
76731   }
76732
76733   jresult = (void *)result;
76734   return jresult;
76735 }
76736
76737
76738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
76739   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76740   float arg2 ;
76741
76742   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76743   arg2 = (float)jarg2;
76744   if (arg1) (arg1)->min = arg2;
76745 }
76746
76747
76748 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
76749   float jresult ;
76750   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76751   float result;
76752
76753   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76754   result = (float) ((arg1)->min);
76755   jresult = result;
76756   return jresult;
76757 }
76758
76759
76760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
76761   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76762   float arg2 ;
76763
76764   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76765   arg2 = (float)jarg2;
76766   if (arg1) (arg1)->max = arg2;
76767 }
76768
76769
76770 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
76771   float jresult ;
76772   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76773   float result;
76774
76775   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76776   result = (float) ((arg1)->max);
76777   jresult = result;
76778   return jresult;
76779 }
76780
76781
76782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
76783   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76784   bool arg2 ;
76785
76786   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76787   arg2 = jarg2 ? true : false;
76788   if (arg1) (arg1)->enabled = arg2;
76789 }
76790
76791
76792 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
76793   unsigned int jresult ;
76794   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76795   bool result;
76796
76797   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76798   result = (bool) ((arg1)->enabled);
76799   jresult = result;
76800   return jresult;
76801 }
76802
76803
76804 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
76805   float jresult ;
76806   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76807   float arg2 ;
76808   float arg3 ;
76809   float arg4 ;
76810   float result;
76811
76812   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76813   arg2 = (float)jarg2;
76814   arg3 = (float)jarg3;
76815   arg4 = (float)jarg4;
76816   {
76817     try {
76818       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
76819     } catch (std::out_of_range& e) {
76820       {
76821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76822       };
76823     } catch (std::exception& e) {
76824       {
76825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76826       };
76827     } catch (Dali::DaliException e) {
76828       {
76829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76830       };
76831     } catch (...) {
76832       {
76833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76834       };
76835     }
76836   }
76837
76838   jresult = result;
76839   return jresult;
76840 }
76841
76842
76843 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
76844   float jresult ;
76845   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76846   float arg2 ;
76847   float arg3 ;
76848   float result;
76849
76850   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76851   arg2 = (float)jarg2;
76852   arg3 = (float)jarg3;
76853   {
76854     try {
76855       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
76856     } catch (std::out_of_range& e) {
76857       {
76858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76859       };
76860     } catch (std::exception& e) {
76861       {
76862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76863       };
76864     } catch (Dali::DaliException e) {
76865       {
76866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76867       };
76868     } catch (...) {
76869       {
76870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76871       };
76872     }
76873   }
76874
76875   jresult = result;
76876   return jresult;
76877 }
76878
76879
76880 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
76881   float jresult ;
76882   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76883   float arg2 ;
76884   float result;
76885
76886   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76887   arg2 = (float)jarg2;
76888   {
76889     try {
76890       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
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 float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
76916   float jresult ;
76917   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76918   float arg2 ;
76919   float arg3 ;
76920   float arg4 ;
76921   Dali::Toolkit::ClampState *arg5 = 0 ;
76922   float result;
76923
76924   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76925   arg2 = (float)jarg2;
76926   arg3 = (float)jarg3;
76927   arg4 = (float)jarg4;
76928   arg5 = (Dali::Toolkit::ClampState *)jarg5;
76929   if (!arg5) {
76930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
76931     return 0;
76932   }
76933   {
76934     try {
76935       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
76936     } catch (std::out_of_range& e) {
76937       {
76938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76939       };
76940     } catch (std::exception& e) {
76941       {
76942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76943       };
76944     } catch (Dali::DaliException e) {
76945       {
76946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76947       };
76948     } catch (...) {
76949       {
76950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76951       };
76952     }
76953   }
76954
76955   jresult = result;
76956   return jresult;
76957 }
76958
76959
76960 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
76961   float jresult ;
76962   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76963   float result;
76964
76965   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76966   {
76967     try {
76968       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
76969     } catch (std::out_of_range& e) {
76970       {
76971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76972       };
76973     } catch (std::exception& e) {
76974       {
76975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76976       };
76977     } catch (Dali::DaliException e) {
76978       {
76979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76980       };
76981     } catch (...) {
76982       {
76983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76984       };
76985     }
76986   }
76987
76988   jresult = result;
76989   return jresult;
76990 }
76991
76992
76993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
76994   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76995
76996   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76997   {
76998     try {
76999       delete arg1;
77000     } catch (std::out_of_range& e) {
77001       {
77002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77003       };
77004     } catch (std::exception& e) {
77005       {
77006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77007       };
77008     } catch (Dali::DaliException e) {
77009       {
77010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77011       };
77012     } catch (...) {
77013       {
77014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77015       };
77016     }
77017   }
77018
77019 }
77020
77021
77022 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
77023   float jresult ;
77024   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77025   float arg2 ;
77026   float arg3 ;
77027   float result;
77028
77029   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77030   arg2 = (float)jarg2;
77031   arg3 = (float)jarg3;
77032   {
77033     try {
77034       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
77035     } catch (std::out_of_range& e) {
77036       {
77037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77038       };
77039     } catch (std::exception& e) {
77040       {
77041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77042       };
77043     } catch (Dali::DaliException e) {
77044       {
77045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77046       };
77047     } catch (...) {
77048       {
77049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77050       };
77051     }
77052   }
77053
77054   jresult = result;
77055   return jresult;
77056 }
77057
77058
77059 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
77060   float jresult ;
77061   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77062   float arg2 ;
77063   float result;
77064
77065   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77066   arg2 = (float)jarg2;
77067   {
77068     try {
77069       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
77070     } catch (std::out_of_range& e) {
77071       {
77072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77073       };
77074     } catch (std::exception& e) {
77075       {
77076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77077       };
77078     } catch (Dali::DaliException e) {
77079       {
77080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77081       };
77082     } catch (...) {
77083       {
77084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77085       };
77086     }
77087   }
77088
77089   jresult = result;
77090   return jresult;
77091 }
77092
77093
77094 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
77095   float jresult ;
77096   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77097   unsigned int arg2 ;
77098   unsigned int *arg3 = 0 ;
77099   bool arg4 ;
77100   float result;
77101
77102   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77103   arg2 = (unsigned int)jarg2;
77104   arg3 = (unsigned int *)jarg3;
77105   arg4 = jarg4 ? true : false;
77106   {
77107     try {
77108       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
77109     } catch (std::out_of_range& e) {
77110       {
77111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77112       };
77113     } catch (std::exception& e) {
77114       {
77115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77116       };
77117     } catch (Dali::DaliException e) {
77118       {
77119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77120       };
77121     } catch (...) {
77122       {
77123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77124       };
77125     }
77126   }
77127
77128   jresult = result;
77129   return jresult;
77130 }
77131
77132
77133 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
77134   unsigned int jresult ;
77135   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77136   float arg2 ;
77137   bool arg3 ;
77138   unsigned int result;
77139
77140   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77141   arg2 = (float)jarg2;
77142   arg3 = jarg3 ? true : false;
77143   {
77144     try {
77145       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
77146     } catch (std::out_of_range& e) {
77147       {
77148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77149       };
77150     } catch (std::exception& e) {
77151       {
77152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77153       };
77154     } catch (Dali::DaliException e) {
77155       {
77156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77157       };
77158     } catch (...) {
77159       {
77160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77161       };
77162     }
77163   }
77164
77165   jresult = result;
77166   return jresult;
77167 }
77168
77169
77170 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
77171   unsigned int jresult ;
77172   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77173   unsigned int result;
77174
77175   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77176   {
77177     try {
77178       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
77179     } catch (std::out_of_range& e) {
77180       {
77181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77182       };
77183     } catch (std::exception& e) {
77184       {
77185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77186       };
77187     } catch (Dali::DaliException e) {
77188       {
77189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77190       };
77191     } catch (...) {
77192       {
77193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77194       };
77195     }
77196   }
77197
77198   jresult = result;
77199   return jresult;
77200 }
77201
77202
77203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
77204   int jresult ;
77205   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77206   Dali::Toolkit::Ruler::RulerType result;
77207
77208   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77209   {
77210     try {
77211       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
77212     } catch (std::out_of_range& e) {
77213       {
77214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77215       };
77216     } catch (std::exception& e) {
77217       {
77218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77219       };
77220     } catch (Dali::DaliException e) {
77221       {
77222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77223       };
77224     } catch (...) {
77225       {
77226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77227       };
77228     }
77229   }
77230
77231   jresult = (int)result;
77232   return jresult;
77233 }
77234
77235
77236 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
77237   unsigned int jresult ;
77238   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77239   bool result;
77240
77241   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77242   {
77243     try {
77244       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
77245     } catch (std::out_of_range& e) {
77246       {
77247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77248       };
77249     } catch (std::exception& e) {
77250       {
77251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77252       };
77253     } catch (Dali::DaliException e) {
77254       {
77255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77256       };
77257     } catch (...) {
77258       {
77259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77260       };
77261     }
77262   }
77263
77264   jresult = result;
77265   return jresult;
77266 }
77267
77268
77269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
77270   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77271
77272   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77273   {
77274     try {
77275       (arg1)->Enable();
77276     } catch (std::out_of_range& e) {
77277       {
77278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77279       };
77280     } catch (std::exception& e) {
77281       {
77282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77283       };
77284     } catch (Dali::DaliException e) {
77285       {
77286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77287       };
77288     } catch (...) {
77289       {
77290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77291       };
77292     }
77293   }
77294
77295 }
77296
77297
77298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
77299   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77300
77301   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77302   {
77303     try {
77304       (arg1)->Disable();
77305     } catch (std::out_of_range& e) {
77306       {
77307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77308       };
77309     } catch (std::exception& e) {
77310       {
77311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77312       };
77313     } catch (Dali::DaliException e) {
77314       {
77315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77316       };
77317     } catch (...) {
77318       {
77319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77320       };
77321     }
77322   }
77323
77324 }
77325
77326
77327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
77328   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77329   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
77330   Dali::Toolkit::RulerDomain *argp2 ;
77331
77332   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77333   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
77334   if (!argp2) {
77335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
77336     return ;
77337   }
77338   arg2 = *argp2;
77339   {
77340     try {
77341       (arg1)->SetDomain(arg2);
77342     } catch (std::out_of_range& e) {
77343       {
77344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77345       };
77346     } catch (std::exception& e) {
77347       {
77348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77349       };
77350     } catch (Dali::DaliException e) {
77351       {
77352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77353       };
77354     } catch (...) {
77355       {
77356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77357       };
77358     }
77359   }
77360
77361 }
77362
77363
77364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
77365   void * jresult ;
77366   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77367   Dali::Toolkit::RulerDomain *result = 0 ;
77368
77369   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77370   {
77371     try {
77372       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
77373     } catch (std::out_of_range& e) {
77374       {
77375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77376       };
77377     } catch (std::exception& e) {
77378       {
77379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77380       };
77381     } catch (Dali::DaliException e) {
77382       {
77383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77384       };
77385     } catch (...) {
77386       {
77387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77388       };
77389     }
77390   }
77391
77392   jresult = (void *)result;
77393   return jresult;
77394 }
77395
77396
77397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
77398   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77399
77400   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77401   {
77402     try {
77403       (arg1)->DisableDomain();
77404     } catch (std::out_of_range& e) {
77405       {
77406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77407       };
77408     } catch (std::exception& e) {
77409       {
77410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77411       };
77412     } catch (Dali::DaliException e) {
77413       {
77414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77415       };
77416     } catch (...) {
77417       {
77418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77419       };
77420     }
77421   }
77422
77423 }
77424
77425
77426 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
77427   float jresult ;
77428   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77429   float arg2 ;
77430   float arg3 ;
77431   float arg4 ;
77432   float result;
77433
77434   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77435   arg2 = (float)jarg2;
77436   arg3 = (float)jarg3;
77437   arg4 = (float)jarg4;
77438   {
77439     try {
77440       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
77441     } catch (std::out_of_range& e) {
77442       {
77443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77444       };
77445     } catch (std::exception& e) {
77446       {
77447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77448       };
77449     } catch (Dali::DaliException e) {
77450       {
77451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77452       };
77453     } catch (...) {
77454       {
77455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77456       };
77457     }
77458   }
77459
77460   jresult = result;
77461   return jresult;
77462 }
77463
77464
77465 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
77466   float jresult ;
77467   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77468   float arg2 ;
77469   float arg3 ;
77470   float result;
77471
77472   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77473   arg2 = (float)jarg2;
77474   arg3 = (float)jarg3;
77475   {
77476     try {
77477       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
77478     } catch (std::out_of_range& e) {
77479       {
77480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77481       };
77482     } catch (std::exception& e) {
77483       {
77484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77485       };
77486     } catch (Dali::DaliException e) {
77487       {
77488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77489       };
77490     } catch (...) {
77491       {
77492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77493       };
77494     }
77495   }
77496
77497   jresult = result;
77498   return jresult;
77499 }
77500
77501
77502 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
77503   float jresult ;
77504   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77505   float arg2 ;
77506   float result;
77507
77508   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77509   arg2 = (float)jarg2;
77510   {
77511     try {
77512       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
77513     } catch (std::out_of_range& e) {
77514       {
77515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77516       };
77517     } catch (std::exception& e) {
77518       {
77519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77520       };
77521     } catch (Dali::DaliException e) {
77522       {
77523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77524       };
77525     } catch (...) {
77526       {
77527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77528       };
77529     }
77530   }
77531
77532   jresult = result;
77533   return jresult;
77534 }
77535
77536
77537 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
77538   float jresult ;
77539   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77540   float arg2 ;
77541   float arg3 ;
77542   float arg4 ;
77543   Dali::Toolkit::ClampState *arg5 = 0 ;
77544   float result;
77545
77546   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77547   arg2 = (float)jarg2;
77548   arg3 = (float)jarg3;
77549   arg4 = (float)jarg4;
77550   arg5 = (Dali::Toolkit::ClampState *)jarg5;
77551   if (!arg5) {
77552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
77553     return 0;
77554   }
77555   {
77556     try {
77557       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
77558     } catch (std::out_of_range& e) {
77559       {
77560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77561       };
77562     } catch (std::exception& e) {
77563       {
77564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77565       };
77566     } catch (Dali::DaliException e) {
77567       {
77568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77569       };
77570     } catch (...) {
77571       {
77572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77573       };
77574     }
77575   }
77576
77577   jresult = result;
77578   return jresult;
77579 }
77580
77581
77582 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
77583   float jresult ;
77584   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77585   float arg2 ;
77586   float arg3 ;
77587   float arg4 ;
77588   float arg5 ;
77589   float result;
77590
77591   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77592   arg2 = (float)jarg2;
77593   arg3 = (float)jarg3;
77594   arg4 = (float)jarg4;
77595   arg5 = (float)jarg5;
77596   {
77597     try {
77598       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
77599     } catch (std::out_of_range& e) {
77600       {
77601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77602       };
77603     } catch (std::exception& e) {
77604       {
77605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77606       };
77607     } catch (Dali::DaliException e) {
77608       {
77609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77610       };
77611     } catch (...) {
77612       {
77613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77614       };
77615     }
77616   }
77617
77618   jresult = result;
77619   return jresult;
77620 }
77621
77622
77623 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
77624   float jresult ;
77625   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77626   float arg2 ;
77627   float arg3 ;
77628   float arg4 ;
77629   float result;
77630
77631   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77632   arg2 = (float)jarg2;
77633   arg3 = (float)jarg3;
77634   arg4 = (float)jarg4;
77635   {
77636     try {
77637       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
77638     } catch (std::out_of_range& e) {
77639       {
77640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77641       };
77642     } catch (std::exception& e) {
77643       {
77644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77645       };
77646     } catch (Dali::DaliException e) {
77647       {
77648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77649       };
77650     } catch (...) {
77651       {
77652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77653       };
77654     }
77655   }
77656
77657   jresult = result;
77658   return jresult;
77659 }
77660
77661
77662 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
77663   float jresult ;
77664   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77665   float arg2 ;
77666   float arg3 ;
77667   float result;
77668
77669   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77670   arg2 = (float)jarg2;
77671   arg3 = (float)jarg3;
77672   {
77673     try {
77674       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
77675     } catch (std::out_of_range& e) {
77676       {
77677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77678       };
77679     } catch (std::exception& e) {
77680       {
77681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77682       };
77683     } catch (Dali::DaliException e) {
77684       {
77685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77686       };
77687     } catch (...) {
77688       {
77689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77690       };
77691     }
77692   }
77693
77694   jresult = result;
77695   return jresult;
77696 }
77697
77698
77699 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
77700   float jresult ;
77701   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77702   float arg2 ;
77703   float result;
77704
77705   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77706   arg2 = (float)jarg2;
77707   {
77708     try {
77709       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
77710     } catch (std::out_of_range& e) {
77711       {
77712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77713       };
77714     } catch (std::exception& e) {
77715       {
77716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77717       };
77718     } catch (Dali::DaliException e) {
77719       {
77720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77721       };
77722     } catch (...) {
77723       {
77724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77725       };
77726     }
77727   }
77728
77729   jresult = result;
77730   return jresult;
77731 }
77732
77733
77734 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
77735   float jresult ;
77736   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77737   float arg2 ;
77738   float arg3 ;
77739   float arg4 ;
77740   float arg5 ;
77741   Dali::Toolkit::ClampState *arg6 = 0 ;
77742   float result;
77743
77744   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77745   arg2 = (float)jarg2;
77746   arg3 = (float)jarg3;
77747   arg4 = (float)jarg4;
77748   arg5 = (float)jarg5;
77749   arg6 = (Dali::Toolkit::ClampState *)jarg6;
77750   if (!arg6) {
77751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
77752     return 0;
77753   }
77754   {
77755     try {
77756       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
77757     } catch (std::out_of_range& e) {
77758       {
77759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77760       };
77761     } catch (std::exception& e) {
77762       {
77763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77764       };
77765     } catch (Dali::DaliException e) {
77766       {
77767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77768       };
77769     } catch (...) {
77770       {
77771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77772       };
77773     }
77774   }
77775
77776   jresult = result;
77777   return jresult;
77778 }
77779
77780
77781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
77782   void * jresult ;
77783   Dali::Toolkit::DefaultRuler *result = 0 ;
77784
77785   {
77786     try {
77787       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
77788     } catch (std::out_of_range& e) {
77789       {
77790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77791       };
77792     } catch (std::exception& e) {
77793       {
77794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77795       };
77796     } catch (Dali::DaliException e) {
77797       {
77798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77799       };
77800     } catch (...) {
77801       {
77802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77803       };
77804     }
77805   }
77806
77807   jresult = (void *)result;
77808   return jresult;
77809 }
77810
77811
77812 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
77813   float jresult ;
77814   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77815   float arg2 ;
77816   float arg3 ;
77817   float result;
77818
77819   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77820   arg2 = (float)jarg2;
77821   arg3 = (float)jarg3;
77822   {
77823     try {
77824       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
77825     } catch (std::out_of_range& e) {
77826       {
77827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77828       };
77829     } catch (std::exception& e) {
77830       {
77831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77832       };
77833     } catch (Dali::DaliException e) {
77834       {
77835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77836       };
77837     } catch (...) {
77838       {
77839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77840       };
77841     }
77842   }
77843
77844   jresult = result;
77845   return jresult;
77846 }
77847
77848
77849 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
77850   float jresult ;
77851   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77852   unsigned int arg2 ;
77853   unsigned int *arg3 = 0 ;
77854   bool arg4 ;
77855   float result;
77856
77857   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77858   arg2 = (unsigned int)jarg2;
77859   arg3 = (unsigned int *)jarg3;
77860   arg4 = jarg4 ? true : false;
77861   {
77862     try {
77863       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
77864     } catch (std::out_of_range& e) {
77865       {
77866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77867       };
77868     } catch (std::exception& e) {
77869       {
77870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77871       };
77872     } catch (Dali::DaliException e) {
77873       {
77874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77875       };
77876     } catch (...) {
77877       {
77878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77879       };
77880     }
77881   }
77882
77883   jresult = result;
77884   return jresult;
77885 }
77886
77887
77888 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
77889   unsigned int jresult ;
77890   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77891   float arg2 ;
77892   bool arg3 ;
77893   unsigned int result;
77894
77895   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77896   arg2 = (float)jarg2;
77897   arg3 = jarg3 ? true : false;
77898   {
77899     try {
77900       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
77901     } catch (std::out_of_range& e) {
77902       {
77903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77904       };
77905     } catch (std::exception& e) {
77906       {
77907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77908       };
77909     } catch (Dali::DaliException e) {
77910       {
77911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77912       };
77913     } catch (...) {
77914       {
77915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77916       };
77917     }
77918   }
77919
77920   jresult = result;
77921   return jresult;
77922 }
77923
77924
77925 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
77926   unsigned int jresult ;
77927   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77928   unsigned int result;
77929
77930   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77931   {
77932     try {
77933       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
77934     } catch (std::out_of_range& e) {
77935       {
77936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77937       };
77938     } catch (std::exception& e) {
77939       {
77940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77941       };
77942     } catch (Dali::DaliException e) {
77943       {
77944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77945       };
77946     } catch (...) {
77947       {
77948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77949       };
77950     }
77951   }
77952
77953   jresult = result;
77954   return jresult;
77955 }
77956
77957
77958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
77959   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77960
77961   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77962   {
77963     try {
77964       delete arg1;
77965     } catch (std::out_of_range& e) {
77966       {
77967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77968       };
77969     } catch (std::exception& e) {
77970       {
77971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77972       };
77973     } catch (Dali::DaliException e) {
77974       {
77975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77976       };
77977     } catch (...) {
77978       {
77979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77980       };
77981     }
77982   }
77983
77984 }
77985
77986
77987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
77988   void * jresult ;
77989   float arg1 ;
77990   Dali::Toolkit::FixedRuler *result = 0 ;
77991
77992   arg1 = (float)jarg1;
77993   {
77994     try {
77995       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
77996     } catch (std::out_of_range& e) {
77997       {
77998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77999       };
78000     } catch (std::exception& e) {
78001       {
78002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78003       };
78004     } catch (Dali::DaliException e) {
78005       {
78006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78007       };
78008     } catch (...) {
78009       {
78010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78011       };
78012     }
78013   }
78014
78015   jresult = (void *)result;
78016   return jresult;
78017 }
78018
78019
78020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
78021   void * jresult ;
78022   Dali::Toolkit::FixedRuler *result = 0 ;
78023
78024   {
78025     try {
78026       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
78027     } catch (std::out_of_range& e) {
78028       {
78029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78030       };
78031     } catch (std::exception& e) {
78032       {
78033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78034       };
78035     } catch (Dali::DaliException e) {
78036       {
78037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78038       };
78039     } catch (...) {
78040       {
78041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78042       };
78043     }
78044   }
78045
78046   jresult = (void *)result;
78047   return jresult;
78048 }
78049
78050
78051 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
78052   float jresult ;
78053   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78054   float arg2 ;
78055   float arg3 ;
78056   float result;
78057
78058   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78059   arg2 = (float)jarg2;
78060   arg3 = (float)jarg3;
78061   {
78062     try {
78063       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
78064     } catch (std::out_of_range& e) {
78065       {
78066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78067       };
78068     } catch (std::exception& e) {
78069       {
78070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78071       };
78072     } catch (Dali::DaliException e) {
78073       {
78074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78075       };
78076     } catch (...) {
78077       {
78078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78079       };
78080     }
78081   }
78082
78083   jresult = result;
78084   return jresult;
78085 }
78086
78087
78088 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78089   float jresult ;
78090   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78091   unsigned int arg2 ;
78092   unsigned int *arg3 = 0 ;
78093   bool arg4 ;
78094   float result;
78095
78096   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78097   arg2 = (unsigned int)jarg2;
78098   arg3 = (unsigned int *)jarg3;
78099   arg4 = jarg4 ? true : false;
78100   {
78101     try {
78102       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78103     } catch (std::out_of_range& e) {
78104       {
78105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78106       };
78107     } catch (std::exception& e) {
78108       {
78109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78110       };
78111     } catch (Dali::DaliException e) {
78112       {
78113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78114       };
78115     } catch (...) {
78116       {
78117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78118       };
78119     }
78120   }
78121
78122   jresult = result;
78123   return jresult;
78124 }
78125
78126
78127 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78128   unsigned int jresult ;
78129   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78130   float arg2 ;
78131   bool arg3 ;
78132   unsigned int result;
78133
78134   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78135   arg2 = (float)jarg2;
78136   arg3 = jarg3 ? true : false;
78137   {
78138     try {
78139       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
78140     } catch (std::out_of_range& e) {
78141       {
78142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78143       };
78144     } catch (std::exception& e) {
78145       {
78146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78147       };
78148     } catch (Dali::DaliException e) {
78149       {
78150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78151       };
78152     } catch (...) {
78153       {
78154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78155       };
78156     }
78157   }
78158
78159   jresult = result;
78160   return jresult;
78161 }
78162
78163
78164 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
78165   unsigned int jresult ;
78166   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78167   unsigned int result;
78168
78169   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78170   {
78171     try {
78172       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
78173     } catch (std::out_of_range& e) {
78174       {
78175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78176       };
78177     } catch (std::exception& e) {
78178       {
78179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78180       };
78181     } catch (Dali::DaliException e) {
78182       {
78183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78184       };
78185     } catch (...) {
78186       {
78187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78188       };
78189     }
78190   }
78191
78192   jresult = result;
78193   return jresult;
78194 }
78195
78196
78197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
78198   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78199
78200   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78201   {
78202     try {
78203       delete arg1;
78204     } catch (std::out_of_range& e) {
78205       {
78206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78207       };
78208     } catch (std::exception& e) {
78209       {
78210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78211       };
78212     } catch (Dali::DaliException e) {
78213       {
78214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78215       };
78216     } catch (...) {
78217       {
78218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78219       };
78220     }
78221   }
78222
78223 }
78224
78225
78226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
78227   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78228   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
78229
78230   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78231   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
78232   if (arg1) (arg1)->scale = *arg2;
78233 }
78234
78235
78236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
78237   void * jresult ;
78238   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78239   Dali::Toolkit::ClampState2D *result = 0 ;
78240
78241   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78242   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
78243   jresult = (void *)result;
78244   return jresult;
78245 }
78246
78247
78248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
78249   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78250   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
78251
78252   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78253   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
78254   if (arg1) (arg1)->position = *arg2;
78255 }
78256
78257
78258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
78259   void * jresult ;
78260   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78261   Dali::Toolkit::ClampState2D *result = 0 ;
78262
78263   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78264   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
78265   jresult = (void *)result;
78266   return jresult;
78267 }
78268
78269
78270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
78271   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78272   Dali::Toolkit::ClampState arg2 ;
78273
78274   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78275   arg2 = (Dali::Toolkit::ClampState)jarg2;
78276   if (arg1) (arg1)->rotation = arg2;
78277 }
78278
78279
78280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
78281   int jresult ;
78282   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78283   Dali::Toolkit::ClampState result;
78284
78285   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78286   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
78287   jresult = (int)result;
78288   return jresult;
78289 }
78290
78291
78292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
78293   void * jresult ;
78294   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
78295
78296   {
78297     try {
78298       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
78299     } catch (std::out_of_range& e) {
78300       {
78301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78302       };
78303     } catch (std::exception& e) {
78304       {
78305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78306       };
78307     } catch (Dali::DaliException e) {
78308       {
78309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78310       };
78311     } catch (...) {
78312       {
78313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78314       };
78315     }
78316   }
78317
78318   jresult = (void *)result;
78319   return jresult;
78320 }
78321
78322
78323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
78324   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78325
78326   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78327   {
78328     try {
78329       delete arg1;
78330     } catch (std::out_of_range& e) {
78331       {
78332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78333       };
78334     } catch (std::exception& e) {
78335       {
78336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78337       };
78338     } catch (Dali::DaliException e) {
78339       {
78340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78341       };
78342     } catch (...) {
78343       {
78344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78345       };
78346     }
78347   }
78348
78349 }
78350
78351
78352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
78353   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78354   Dali::Toolkit::SnapType arg2 ;
78355
78356   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78357   arg2 = (Dali::Toolkit::SnapType)jarg2;
78358   if (arg1) (arg1)->type = arg2;
78359 }
78360
78361
78362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
78363   int jresult ;
78364   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78365   Dali::Toolkit::SnapType result;
78366
78367   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78368   result = (Dali::Toolkit::SnapType) ((arg1)->type);
78369   jresult = (int)result;
78370   return jresult;
78371 }
78372
78373
78374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
78375   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78376   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
78377
78378   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78379   arg2 = (Dali::Vector2 *)jarg2;
78380   if (arg1) (arg1)->position = *arg2;
78381 }
78382
78383
78384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
78385   void * jresult ;
78386   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78387   Dali::Vector2 *result = 0 ;
78388
78389   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78390   result = (Dali::Vector2 *)& ((arg1)->position);
78391   jresult = (void *)result;
78392   return jresult;
78393 }
78394
78395
78396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
78397   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78398   float arg2 ;
78399
78400   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78401   arg2 = (float)jarg2;
78402   if (arg1) (arg1)->duration = arg2;
78403 }
78404
78405
78406 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
78407   float jresult ;
78408   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78409   float result;
78410
78411   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78412   result = (float) ((arg1)->duration);
78413   jresult = result;
78414   return jresult;
78415 }
78416
78417
78418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
78419   void * jresult ;
78420   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
78421
78422   {
78423     try {
78424       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
78425     } catch (std::out_of_range& e) {
78426       {
78427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78428       };
78429     } catch (std::exception& e) {
78430       {
78431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78432       };
78433     } catch (Dali::DaliException e) {
78434       {
78435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78436       };
78437     } catch (...) {
78438       {
78439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78440       };
78441     }
78442   }
78443
78444   jresult = (void *)result;
78445   return jresult;
78446 }
78447
78448
78449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
78450   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78451
78452   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78453   {
78454     try {
78455       delete arg1;
78456     } catch (std::out_of_range& e) {
78457       {
78458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78459       };
78460     } catch (std::exception& e) {
78461       {
78462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78463       };
78464     } catch (Dali::DaliException e) {
78465       {
78466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78467       };
78468     } catch (...) {
78469       {
78470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78471       };
78472     }
78473   }
78474
78475 }
78476
78477
78478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
78479   int jresult ;
78480   int result;
78481
78482   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
78483   jresult = (int)result;
78484   return jresult;
78485 }
78486
78487
78488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
78489   int jresult ;
78490   int result;
78491
78492   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
78493   jresult = (int)result;
78494   return jresult;
78495 }
78496
78497
78498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
78499   int jresult ;
78500   int result;
78501
78502   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
78503   jresult = (int)result;
78504   return jresult;
78505 }
78506
78507
78508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
78509   int jresult ;
78510   int result;
78511
78512   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
78513   jresult = (int)result;
78514   return jresult;
78515 }
78516
78517
78518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
78519   int jresult ;
78520   int result;
78521
78522   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
78523   jresult = (int)result;
78524   return jresult;
78525 }
78526
78527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
78528   int jresult ;
78529   int result;
78530
78531   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
78532   jresult = (int)result;
78533   return jresult;
78534 }
78535
78536
78537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
78538   int jresult ;
78539   int result;
78540
78541   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
78542   jresult = (int)result;
78543   return jresult;
78544 }
78545
78546
78547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
78548   int jresult ;
78549   int result;
78550
78551   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
78552   jresult = (int)result;
78553   return jresult;
78554 }
78555
78556
78557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
78558   int jresult ;
78559   int result;
78560
78561   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
78562   jresult = (int)result;
78563   return jresult;
78564 }
78565
78566
78567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
78568   int jresult ;
78569   int result;
78570
78571   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
78572   jresult = (int)result;
78573   return jresult;
78574 }
78575
78576
78577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
78578   int jresult ;
78579   int result;
78580
78581   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
78582   jresult = (int)result;
78583   return jresult;
78584 }
78585
78586
78587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
78588   int jresult ;
78589   int result;
78590
78591   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
78592   jresult = (int)result;
78593   return jresult;
78594 }
78595
78596
78597 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
78598   int jresult ;
78599   int result;
78600
78601   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
78602   jresult = (int)result;
78603   return jresult;
78604 }
78605
78606
78607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
78608   int jresult ;
78609   int result;
78610
78611   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
78612   jresult = (int)result;
78613   return jresult;
78614 }
78615
78616
78617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
78618   int jresult ;
78619   int result;
78620
78621   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
78622   jresult = (int)result;
78623   return jresult;
78624 }
78625
78626
78627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
78628   int jresult ;
78629   int result;
78630
78631   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
78632   jresult = (int)result;
78633   return jresult;
78634 }
78635
78636
78637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
78638   int jresult ;
78639   int result;
78640
78641   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
78642   jresult = (int)result;
78643   return jresult;
78644 }
78645
78646
78647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
78648   int jresult ;
78649   int result;
78650
78651   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
78652   jresult = (int)result;
78653   return jresult;
78654 }
78655
78656
78657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
78658   int jresult ;
78659   int result;
78660
78661   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
78662   jresult = (int)result;
78663   return jresult;
78664 }
78665
78666
78667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
78668   int jresult ;
78669   int result;
78670
78671   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
78672   jresult = (int)result;
78673   return jresult;
78674 }
78675
78676
78677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
78678   int jresult ;
78679   int result;
78680
78681   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
78682   jresult = (int)result;
78683   return jresult;
78684 }
78685
78686
78687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
78688   int jresult ;
78689   int result;
78690
78691   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
78692   jresult = (int)result;
78693   return jresult;
78694 }
78695
78696
78697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
78698   int jresult ;
78699   int result;
78700
78701   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
78702   jresult = (int)result;
78703   return jresult;
78704 }
78705
78706
78707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
78708   int jresult ;
78709   int result;
78710
78711   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
78712   jresult = (int)result;
78713   return jresult;
78714 }
78715
78716
78717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
78718   int jresult ;
78719   int result;
78720
78721   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
78722   jresult = (int)result;
78723   return jresult;
78724 }
78725
78726
78727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
78728   int jresult ;
78729   int result;
78730
78731   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
78732   jresult = (int)result;
78733   return jresult;
78734 }
78735
78736
78737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
78738   void * jresult ;
78739   Dali::Toolkit::ScrollView::Property *result = 0 ;
78740
78741   {
78742     try {
78743       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
78744     } catch (std::out_of_range& e) {
78745       {
78746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78747       };
78748     } catch (std::exception& e) {
78749       {
78750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78751       };
78752     } catch (Dali::DaliException e) {
78753       {
78754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78755       };
78756     } catch (...) {
78757       {
78758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78759       };
78760     }
78761   }
78762
78763   jresult = (void *)result;
78764   return jresult;
78765 }
78766
78767
78768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
78769   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
78770
78771   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
78772   {
78773     try {
78774       delete arg1;
78775     } catch (std::out_of_range& e) {
78776       {
78777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78778       };
78779     } catch (std::exception& e) {
78780       {
78781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78782       };
78783     } catch (Dali::DaliException e) {
78784       {
78785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78786       };
78787     } catch (...) {
78788       {
78789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78790       };
78791     }
78792   }
78793
78794 }
78795
78796
78797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
78798   void * jresult ;
78799   Dali::Toolkit::ScrollView *result = 0 ;
78800
78801   {
78802     try {
78803       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
78804     } catch (std::out_of_range& e) {
78805       {
78806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78807       };
78808     } catch (std::exception& e) {
78809       {
78810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78811       };
78812     } catch (Dali::DaliException e) {
78813       {
78814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78815       };
78816     } catch (...) {
78817       {
78818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78819       };
78820     }
78821   }
78822
78823   jresult = (void *)result;
78824   return jresult;
78825 }
78826
78827
78828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
78829   void * jresult ;
78830   Dali::Toolkit::ScrollView *arg1 = 0 ;
78831   Dali::Toolkit::ScrollView *result = 0 ;
78832
78833   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78834   if (!arg1) {
78835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
78836     return 0;
78837   }
78838   {
78839     try {
78840       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
78841     } catch (std::out_of_range& e) {
78842       {
78843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78844       };
78845     } catch (std::exception& e) {
78846       {
78847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78848       };
78849     } catch (Dali::DaliException e) {
78850       {
78851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78852       };
78853     } catch (...) {
78854       {
78855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78856       };
78857     }
78858   }
78859
78860   jresult = (void *)result;
78861   return jresult;
78862 }
78863
78864
78865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
78866   void * jresult ;
78867   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78868   Dali::Toolkit::ScrollView *arg2 = 0 ;
78869   Dali::Toolkit::ScrollView *result = 0 ;
78870
78871   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78872   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
78873   if (!arg2) {
78874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
78875     return 0;
78876   }
78877   {
78878     try {
78879       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
78880     } catch (std::out_of_range& e) {
78881       {
78882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78883       };
78884     } catch (std::exception& e) {
78885       {
78886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78887       };
78888     } catch (Dali::DaliException e) {
78889       {
78890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78891       };
78892     } catch (...) {
78893       {
78894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78895       };
78896     }
78897   }
78898
78899   jresult = (void *)result;
78900   return jresult;
78901 }
78902
78903
78904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
78905   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78906
78907   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78908   {
78909     try {
78910       delete arg1;
78911     } catch (std::out_of_range& e) {
78912       {
78913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78914       };
78915     } catch (std::exception& e) {
78916       {
78917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78918       };
78919     } catch (Dali::DaliException e) {
78920       {
78921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78922       };
78923     } catch (...) {
78924       {
78925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78926       };
78927     }
78928   }
78929
78930 }
78931
78932
78933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
78934   void * jresult ;
78935   Dali::Toolkit::ScrollView result;
78936
78937   {
78938     try {
78939       result = Dali::Toolkit::ScrollView::New();
78940     } catch (std::out_of_range& e) {
78941       {
78942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78943       };
78944     } catch (std::exception& e) {
78945       {
78946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78947       };
78948     } catch (Dali::DaliException e) {
78949       {
78950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78951       };
78952     } catch (...) {
78953       {
78954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78955       };
78956     }
78957   }
78958
78959   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
78960   return jresult;
78961 }
78962
78963
78964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
78965   void * jresult ;
78966   Dali::BaseHandle arg1 ;
78967   Dali::BaseHandle *argp1 ;
78968   Dali::Toolkit::ScrollView result;
78969
78970   argp1 = (Dali::BaseHandle *)jarg1;
78971   if (!argp1) {
78972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78973     return 0;
78974   }
78975   arg1 = *argp1;
78976   {
78977     try {
78978       result = Dali::Toolkit::ScrollView::DownCast(arg1);
78979     } catch (std::out_of_range& e) {
78980       {
78981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78982       };
78983     } catch (std::exception& e) {
78984       {
78985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78986       };
78987     } catch (Dali::DaliException e) {
78988       {
78989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78990       };
78991     } catch (...) {
78992       {
78993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78994       };
78995     }
78996   }
78997
78998   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
78999   return jresult;
79000 }
79001
79002
79003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
79004   void * jresult ;
79005   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79006   Dali::AlphaFunction result;
79007
79008   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79009   {
79010     try {
79011       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
79012     } catch (std::out_of_range& e) {
79013       {
79014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79015       };
79016     } catch (std::exception& e) {
79017       {
79018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79019       };
79020     } catch (Dali::DaliException e) {
79021       {
79022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79023       };
79024     } catch (...) {
79025       {
79026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79027       };
79028     }
79029   }
79030
79031   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
79032   return jresult;
79033 }
79034
79035
79036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
79037   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79038   Dali::AlphaFunction arg2 ;
79039   Dali::AlphaFunction *argp2 ;
79040
79041   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79042   argp2 = (Dali::AlphaFunction *)jarg2;
79043   if (!argp2) {
79044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
79045     return ;
79046   }
79047   arg2 = *argp2;
79048   {
79049     try {
79050       (arg1)->SetScrollSnapAlphaFunction(arg2);
79051     } catch (std::out_of_range& e) {
79052       {
79053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79054       };
79055     } catch (std::exception& e) {
79056       {
79057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79058       };
79059     } catch (Dali::DaliException e) {
79060       {
79061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79062       };
79063     } catch (...) {
79064       {
79065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79066       };
79067     }
79068   }
79069
79070 }
79071
79072
79073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
79074   void * jresult ;
79075   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79076   Dali::AlphaFunction result;
79077
79078   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79079   {
79080     try {
79081       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
79082     } catch (std::out_of_range& e) {
79083       {
79084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79085       };
79086     } catch (std::exception& e) {
79087       {
79088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79089       };
79090     } catch (Dali::DaliException e) {
79091       {
79092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79093       };
79094     } catch (...) {
79095       {
79096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79097       };
79098     }
79099   }
79100
79101   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
79102   return jresult;
79103 }
79104
79105
79106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
79107   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79108   Dali::AlphaFunction arg2 ;
79109   Dali::AlphaFunction *argp2 ;
79110
79111   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79112   argp2 = (Dali::AlphaFunction *)jarg2;
79113   if (!argp2) {
79114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
79115     return ;
79116   }
79117   arg2 = *argp2;
79118   {
79119     try {
79120       (arg1)->SetScrollFlickAlphaFunction(arg2);
79121     } catch (std::out_of_range& e) {
79122       {
79123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79124       };
79125     } catch (std::exception& e) {
79126       {
79127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79128       };
79129     } catch (Dali::DaliException e) {
79130       {
79131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79132       };
79133     } catch (...) {
79134       {
79135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79136       };
79137     }
79138   }
79139
79140 }
79141
79142
79143 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
79144   float jresult ;
79145   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79146   float result;
79147
79148   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79149   {
79150     try {
79151       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
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_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
79177   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79178   float arg2 ;
79179
79180   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79181   arg2 = (float)jarg2;
79182   {
79183     try {
79184       (arg1)->SetScrollSnapDuration(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 float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
79208   float jresult ;
79209   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79210   float result;
79211
79212   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79213   {
79214     try {
79215       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
79216     } catch (std::out_of_range& e) {
79217       {
79218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79219       };
79220     } catch (std::exception& e) {
79221       {
79222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79223       };
79224     } catch (Dali::DaliException e) {
79225       {
79226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79227       };
79228     } catch (...) {
79229       {
79230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79231       };
79232     }
79233   }
79234
79235   jresult = result;
79236   return jresult;
79237 }
79238
79239
79240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
79241   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79242   float arg2 ;
79243
79244   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79245   arg2 = (float)jarg2;
79246   {
79247     try {
79248       (arg1)->SetScrollFlickDuration(arg2);
79249     } catch (std::out_of_range& e) {
79250       {
79251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79252       };
79253     } catch (std::exception& e) {
79254       {
79255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79256       };
79257     } catch (Dali::DaliException e) {
79258       {
79259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79260       };
79261     } catch (...) {
79262       {
79263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79264       };
79265     }
79266   }
79267
79268 }
79269
79270
79271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
79272   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79273   Dali::Toolkit::RulerPtr arg2 ;
79274   Dali::Toolkit::RulerPtr *argp2 ;
79275
79276   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79277   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
79278   if (!argp2) {
79279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
79280     return ;
79281   }
79282   arg2 = *argp2;
79283   {
79284     try {
79285       (arg1)->SetRulerX(arg2);
79286     } catch (std::out_of_range& e) {
79287       {
79288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79289       };
79290     } catch (std::exception& e) {
79291       {
79292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79293       };
79294     } catch (Dali::DaliException e) {
79295       {
79296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79297       };
79298     } catch (...) {
79299       {
79300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79301       };
79302     }
79303   }
79304
79305 }
79306
79307
79308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
79309   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79310   Dali::Toolkit::RulerPtr arg2 ;
79311   Dali::Toolkit::RulerPtr *argp2 ;
79312
79313   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79314   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
79315   if (!argp2) {
79316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
79317     return ;
79318   }
79319   arg2 = *argp2;
79320   {
79321     try {
79322       (arg1)->SetRulerY(arg2);
79323     } catch (std::out_of_range& e) {
79324       {
79325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79326       };
79327     } catch (std::exception& e) {
79328       {
79329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79330       };
79331     } catch (Dali::DaliException e) {
79332       {
79333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79334       };
79335     } catch (...) {
79336       {
79337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79338       };
79339     }
79340   }
79341
79342 }
79343
79344
79345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
79346   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79347   bool arg2 ;
79348
79349   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79350   arg2 = jarg2 ? true : false;
79351   {
79352     try {
79353       (arg1)->SetScrollSensitive(arg2);
79354     } catch (std::out_of_range& e) {
79355       {
79356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79357       };
79358     } catch (std::exception& e) {
79359       {
79360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79361       };
79362     } catch (Dali::DaliException e) {
79363       {
79364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79365       };
79366     } catch (...) {
79367       {
79368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79369       };
79370     }
79371   }
79372
79373 }
79374
79375
79376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
79377   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79378   float arg2 ;
79379   float arg3 ;
79380
79381   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79382   arg2 = (float)jarg2;
79383   arg3 = (float)jarg3;
79384   {
79385     try {
79386       (arg1)->SetMaxOvershoot(arg2,arg3);
79387     } catch (std::out_of_range& e) {
79388       {
79389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79390       };
79391     } catch (std::exception& e) {
79392       {
79393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79394       };
79395     } catch (Dali::DaliException e) {
79396       {
79397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79398       };
79399     } catch (...) {
79400       {
79401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79402       };
79403     }
79404   }
79405
79406 }
79407
79408
79409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
79410   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79411   Dali::AlphaFunction arg2 ;
79412   Dali::AlphaFunction *argp2 ;
79413
79414   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79415   argp2 = (Dali::AlphaFunction *)jarg2;
79416   if (!argp2) {
79417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
79418     return ;
79419   }
79420   arg2 = *argp2;
79421   {
79422     try {
79423       (arg1)->SetSnapOvershootAlphaFunction(arg2);
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_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
79447   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79448   float arg2 ;
79449
79450   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79451   arg2 = (float)jarg2;
79452   {
79453     try {
79454       (arg1)->SetSnapOvershootDuration(arg2);
79455     } catch (std::out_of_range& e) {
79456       {
79457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79458       };
79459     } catch (std::exception& e) {
79460       {
79461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79462       };
79463     } catch (Dali::DaliException e) {
79464       {
79465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79466       };
79467     } catch (...) {
79468       {
79469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79470       };
79471     }
79472   }
79473
79474 }
79475
79476
79477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
79478   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79479   bool arg2 ;
79480
79481   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79482   arg2 = jarg2 ? true : false;
79483   {
79484     try {
79485       (arg1)->SetActorAutoSnap(arg2);
79486     } catch (std::out_of_range& e) {
79487       {
79488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79489       };
79490     } catch (std::exception& e) {
79491       {
79492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79493       };
79494     } catch (Dali::DaliException e) {
79495       {
79496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79497       };
79498     } catch (...) {
79499       {
79500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79501       };
79502     }
79503   }
79504
79505 }
79506
79507
79508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
79509   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79510   bool arg2 ;
79511
79512   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79513   arg2 = jarg2 ? true : false;
79514   {
79515     try {
79516       (arg1)->SetWrapMode(arg2);
79517     } catch (std::out_of_range& e) {
79518       {
79519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79520       };
79521     } catch (std::exception& e) {
79522       {
79523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79524       };
79525     } catch (Dali::DaliException e) {
79526       {
79527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79528       };
79529     } catch (...) {
79530       {
79531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79532       };
79533     }
79534   }
79535
79536 }
79537
79538
79539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
79540   int jresult ;
79541   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79542   int result;
79543
79544   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79545   {
79546     try {
79547       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
79548     } catch (std::out_of_range& e) {
79549       {
79550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79551       };
79552     } catch (std::exception& e) {
79553       {
79554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79555       };
79556     } catch (Dali::DaliException e) {
79557       {
79558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79559       };
79560     } catch (...) {
79561       {
79562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79563       };
79564     }
79565   }
79566
79567   jresult = result;
79568   return jresult;
79569 }
79570
79571
79572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
79573   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79574   int arg2 ;
79575
79576   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79577   arg2 = (int)jarg2;
79578   {
79579     try {
79580       (arg1)->SetScrollUpdateDistance(arg2);
79581     } catch (std::out_of_range& e) {
79582       {
79583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79584       };
79585     } catch (std::exception& e) {
79586       {
79587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79588       };
79589     } catch (Dali::DaliException e) {
79590       {
79591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79592       };
79593     } catch (...) {
79594       {
79595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79596       };
79597     }
79598   }
79599
79600 }
79601
79602
79603 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
79604   unsigned int jresult ;
79605   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79606   bool result;
79607
79608   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79609   {
79610     try {
79611       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
79612     } catch (std::out_of_range& e) {
79613       {
79614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79615       };
79616     } catch (std::exception& e) {
79617       {
79618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79619       };
79620     } catch (Dali::DaliException e) {
79621       {
79622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79623       };
79624     } catch (...) {
79625       {
79626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79627       };
79628     }
79629   }
79630
79631   jresult = result;
79632   return jresult;
79633 }
79634
79635
79636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
79637   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79638   bool arg2 ;
79639
79640   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79641   arg2 = jarg2 ? true : false;
79642   {
79643     try {
79644       (arg1)->SetAxisAutoLock(arg2);
79645     } catch (std::out_of_range& e) {
79646       {
79647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79648       };
79649     } catch (std::exception& e) {
79650       {
79651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79652       };
79653     } catch (Dali::DaliException e) {
79654       {
79655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79656       };
79657     } catch (...) {
79658       {
79659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79660       };
79661     }
79662   }
79663
79664 }
79665
79666
79667 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
79668   float jresult ;
79669   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79670   float result;
79671
79672   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79673   {
79674     try {
79675       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
79676     } catch (std::out_of_range& e) {
79677       {
79678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79679       };
79680     } catch (std::exception& e) {
79681       {
79682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79683       };
79684     } catch (Dali::DaliException e) {
79685       {
79686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79687       };
79688     } catch (...) {
79689       {
79690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79691       };
79692     }
79693   }
79694
79695   jresult = result;
79696   return jresult;
79697 }
79698
79699
79700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
79701   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79702   float arg2 ;
79703
79704   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79705   arg2 = (float)jarg2;
79706   {
79707     try {
79708       (arg1)->SetAxisAutoLockGradient(arg2);
79709     } catch (std::out_of_range& e) {
79710       {
79711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79712       };
79713     } catch (std::exception& e) {
79714       {
79715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79716       };
79717     } catch (Dali::DaliException e) {
79718       {
79719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79720       };
79721     } catch (...) {
79722       {
79723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79724       };
79725     }
79726   }
79727
79728 }
79729
79730
79731 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
79732   float jresult ;
79733   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79734   float result;
79735
79736   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79737   {
79738     try {
79739       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
79740     } catch (std::out_of_range& e) {
79741       {
79742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79743       };
79744     } catch (std::exception& e) {
79745       {
79746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79747       };
79748     } catch (Dali::DaliException e) {
79749       {
79750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79751       };
79752     } catch (...) {
79753       {
79754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79755       };
79756     }
79757   }
79758
79759   jresult = result;
79760   return jresult;
79761 }
79762
79763
79764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
79765   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79766   float arg2 ;
79767
79768   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79769   arg2 = (float)jarg2;
79770   {
79771     try {
79772       (arg1)->SetFrictionCoefficient(arg2);
79773     } catch (std::out_of_range& e) {
79774       {
79775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79776       };
79777     } catch (std::exception& e) {
79778       {
79779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79780       };
79781     } catch (Dali::DaliException e) {
79782       {
79783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79784       };
79785     } catch (...) {
79786       {
79787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79788       };
79789     }
79790   }
79791
79792 }
79793
79794
79795 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
79796   float jresult ;
79797   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79798   float result;
79799
79800   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79801   {
79802     try {
79803       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
79804     } catch (std::out_of_range& e) {
79805       {
79806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79807       };
79808     } catch (std::exception& e) {
79809       {
79810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79811       };
79812     } catch (Dali::DaliException e) {
79813       {
79814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79815       };
79816     } catch (...) {
79817       {
79818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79819       };
79820     }
79821   }
79822
79823   jresult = result;
79824   return jresult;
79825 }
79826
79827
79828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
79829   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79830   float arg2 ;
79831
79832   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79833   arg2 = (float)jarg2;
79834   {
79835     try {
79836       (arg1)->SetFlickSpeedCoefficient(arg2);
79837     } catch (std::out_of_range& e) {
79838       {
79839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79840       };
79841     } catch (std::exception& e) {
79842       {
79843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79844       };
79845     } catch (Dali::DaliException e) {
79846       {
79847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79848       };
79849     } catch (...) {
79850       {
79851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79852       };
79853     }
79854   }
79855
79856 }
79857
79858
79859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
79860   void * jresult ;
79861   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79862   Dali::Vector2 result;
79863
79864   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79865   {
79866     try {
79867       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
79868     } catch (std::out_of_range& e) {
79869       {
79870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79871       };
79872     } catch (std::exception& e) {
79873       {
79874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79875       };
79876     } catch (Dali::DaliException e) {
79877       {
79878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79879       };
79880     } catch (...) {
79881       {
79882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79883       };
79884     }
79885   }
79886
79887   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
79888   return jresult;
79889 }
79890
79891
79892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
79893   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79894   Dali::Vector2 *arg2 = 0 ;
79895
79896   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79897   arg2 = (Dali::Vector2 *)jarg2;
79898   if (!arg2) {
79899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
79900     return ;
79901   }
79902   {
79903     try {
79904       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
79905     } catch (std::out_of_range& e) {
79906       {
79907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79908       };
79909     } catch (std::exception& e) {
79910       {
79911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79912       };
79913     } catch (Dali::DaliException e) {
79914       {
79915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79916       };
79917     } catch (...) {
79918       {
79919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79920       };
79921     }
79922   }
79923
79924 }
79925
79926
79927 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
79928   float jresult ;
79929   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79930   float result;
79931
79932   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79933   {
79934     try {
79935       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
79936     } catch (std::out_of_range& e) {
79937       {
79938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79939       };
79940     } catch (std::exception& e) {
79941       {
79942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79943       };
79944     } catch (Dali::DaliException e) {
79945       {
79946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79947       };
79948     } catch (...) {
79949       {
79950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79951       };
79952     }
79953   }
79954
79955   jresult = result;
79956   return jresult;
79957 }
79958
79959
79960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
79961   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79962   float arg2 ;
79963
79964   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79965   arg2 = (float)jarg2;
79966   {
79967     try {
79968       (arg1)->SetMinimumSpeedForFlick(arg2);
79969     } catch (std::out_of_range& e) {
79970       {
79971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79972       };
79973     } catch (std::exception& e) {
79974       {
79975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79976       };
79977     } catch (Dali::DaliException e) {
79978       {
79979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79980       };
79981     } catch (...) {
79982       {
79983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79984       };
79985     }
79986   }
79987
79988 }
79989
79990
79991 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
79992   float jresult ;
79993   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79994   float result;
79995
79996   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79997   {
79998     try {
79999       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
80000     } catch (std::out_of_range& e) {
80001       {
80002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80003       };
80004     } catch (std::exception& e) {
80005       {
80006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80007       };
80008     } catch (Dali::DaliException e) {
80009       {
80010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80011       };
80012     } catch (...) {
80013       {
80014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80015       };
80016     }
80017   }
80018
80019   jresult = result;
80020   return jresult;
80021 }
80022
80023
80024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
80025   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80026   float arg2 ;
80027
80028   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80029   arg2 = (float)jarg2;
80030   {
80031     try {
80032       (arg1)->SetMaxFlickSpeed(arg2);
80033     } catch (std::out_of_range& e) {
80034       {
80035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80036       };
80037     } catch (std::exception& e) {
80038       {
80039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80040       };
80041     } catch (Dali::DaliException e) {
80042       {
80043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80044       };
80045     } catch (...) {
80046       {
80047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80048       };
80049     }
80050   }
80051
80052 }
80053
80054
80055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
80056   void * jresult ;
80057   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80058   Dali::Vector2 result;
80059
80060   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80061   {
80062     try {
80063       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
80064     } catch (std::out_of_range& e) {
80065       {
80066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80067       };
80068     } catch (std::exception& e) {
80069       {
80070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80071       };
80072     } catch (Dali::DaliException e) {
80073       {
80074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80075       };
80076     } catch (...) {
80077       {
80078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80079       };
80080     }
80081   }
80082
80083   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80084   return jresult;
80085 }
80086
80087
80088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
80089   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80090   Dali::Vector2 arg2 ;
80091   Dali::Vector2 *argp2 ;
80092
80093   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80094   argp2 = (Dali::Vector2 *)jarg2;
80095   if (!argp2) {
80096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
80097     return ;
80098   }
80099   arg2 = *argp2;
80100   {
80101     try {
80102       (arg1)->SetWheelScrollDistanceStep(arg2);
80103     } catch (std::out_of_range& e) {
80104       {
80105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80106       };
80107     } catch (std::exception& e) {
80108       {
80109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80110       };
80111     } catch (Dali::DaliException e) {
80112       {
80113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80114       };
80115     } catch (...) {
80116       {
80117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80118       };
80119     }
80120   }
80121
80122 }
80123
80124
80125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
80126   void * jresult ;
80127   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80128   Dali::Vector2 result;
80129
80130   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80131   {
80132     try {
80133       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
80134     } catch (std::out_of_range& e) {
80135       {
80136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80137       };
80138     } catch (std::exception& e) {
80139       {
80140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80141       };
80142     } catch (Dali::DaliException e) {
80143       {
80144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80145       };
80146     } catch (...) {
80147       {
80148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80149       };
80150     }
80151   }
80152
80153   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80154   return jresult;
80155 }
80156
80157
80158 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
80159   unsigned int jresult ;
80160   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80161   unsigned int result;
80162
80163   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80164   {
80165     try {
80166       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
80167     } catch (std::out_of_range& e) {
80168       {
80169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80170       };
80171     } catch (std::exception& e) {
80172       {
80173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80174       };
80175     } catch (Dali::DaliException e) {
80176       {
80177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80178       };
80179     } catch (...) {
80180       {
80181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80182       };
80183     }
80184   }
80185
80186   jresult = result;
80187   return jresult;
80188 }
80189
80190
80191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
80192   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80193   Dali::Vector2 *arg2 = 0 ;
80194
80195   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80196   arg2 = (Dali::Vector2 *)jarg2;
80197   if (!arg2) {
80198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80199     return ;
80200   }
80201   {
80202     try {
80203       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
80204     } catch (std::out_of_range& e) {
80205       {
80206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80207       };
80208     } catch (std::exception& e) {
80209       {
80210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80211       };
80212     } catch (Dali::DaliException e) {
80213       {
80214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80215       };
80216     } catch (...) {
80217       {
80218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80219       };
80220     }
80221   }
80222
80223 }
80224
80225
80226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
80227   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80228   Dali::Vector2 *arg2 = 0 ;
80229   float arg3 ;
80230
80231   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80232   arg2 = (Dali::Vector2 *)jarg2;
80233   if (!arg2) {
80234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80235     return ;
80236   }
80237   arg3 = (float)jarg3;
80238   {
80239     try {
80240       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
80241     } catch (std::out_of_range& e) {
80242       {
80243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80244       };
80245     } catch (std::exception& e) {
80246       {
80247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80248       };
80249     } catch (Dali::DaliException e) {
80250       {
80251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80252       };
80253     } catch (...) {
80254       {
80255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80256       };
80257     }
80258   }
80259
80260 }
80261
80262
80263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
80264   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80265   Dali::Vector2 *arg2 = 0 ;
80266   float arg3 ;
80267   Dali::AlphaFunction arg4 ;
80268   Dali::AlphaFunction *argp4 ;
80269
80270   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80271   arg2 = (Dali::Vector2 *)jarg2;
80272   if (!arg2) {
80273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80274     return ;
80275   }
80276   arg3 = (float)jarg3;
80277   argp4 = (Dali::AlphaFunction *)jarg4;
80278   if (!argp4) {
80279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80280     return ;
80281   }
80282   arg4 = *argp4;
80283   {
80284     try {
80285       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
80286     } catch (std::out_of_range& e) {
80287       {
80288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80289       };
80290     } catch (std::exception& e) {
80291       {
80292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80293       };
80294     } catch (Dali::DaliException e) {
80295       {
80296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80297       };
80298     } catch (...) {
80299       {
80300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80301       };
80302     }
80303   }
80304
80305 }
80306
80307
80308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
80309   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80310   Dali::Vector2 *arg2 = 0 ;
80311   float arg3 ;
80312   Dali::Toolkit::DirectionBias arg4 ;
80313   Dali::Toolkit::DirectionBias arg5 ;
80314
80315   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80316   arg2 = (Dali::Vector2 *)jarg2;
80317   if (!arg2) {
80318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80319     return ;
80320   }
80321   arg3 = (float)jarg3;
80322   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
80323   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
80324   {
80325     try {
80326       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
80327     } catch (std::out_of_range& e) {
80328       {
80329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80330       };
80331     } catch (std::exception& e) {
80332       {
80333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80334       };
80335     } catch (Dali::DaliException e) {
80336       {
80337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80338       };
80339     } catch (...) {
80340       {
80341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80342       };
80343     }
80344   }
80345
80346 }
80347
80348
80349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
80350   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80351   Dali::Vector2 *arg2 = 0 ;
80352   float arg3 ;
80353   Dali::AlphaFunction arg4 ;
80354   Dali::Toolkit::DirectionBias arg5 ;
80355   Dali::Toolkit::DirectionBias arg6 ;
80356   Dali::AlphaFunction *argp4 ;
80357
80358   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80359   arg2 = (Dali::Vector2 *)jarg2;
80360   if (!arg2) {
80361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80362     return ;
80363   }
80364   arg3 = (float)jarg3;
80365   argp4 = (Dali::AlphaFunction *)jarg4;
80366   if (!argp4) {
80367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80368     return ;
80369   }
80370   arg4 = *argp4;
80371   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
80372   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
80373   {
80374     try {
80375       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
80376     } catch (std::out_of_range& e) {
80377       {
80378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80379       };
80380     } catch (std::exception& e) {
80381       {
80382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80383       };
80384     } catch (Dali::DaliException e) {
80385       {
80386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80387       };
80388     } catch (...) {
80389       {
80390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80391       };
80392     }
80393   }
80394
80395 }
80396
80397
80398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
80399   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80400   unsigned int arg2 ;
80401
80402   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80403   arg2 = (unsigned int)jarg2;
80404   {
80405     try {
80406       (arg1)->ScrollTo(arg2);
80407     } catch (std::out_of_range& e) {
80408       {
80409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80410       };
80411     } catch (std::exception& e) {
80412       {
80413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80414       };
80415     } catch (Dali::DaliException e) {
80416       {
80417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80418       };
80419     } catch (...) {
80420       {
80421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80422       };
80423     }
80424   }
80425
80426 }
80427
80428
80429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
80430   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80431   unsigned int arg2 ;
80432   float arg3 ;
80433
80434   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80435   arg2 = (unsigned int)jarg2;
80436   arg3 = (float)jarg3;
80437   {
80438     try {
80439       (arg1)->ScrollTo(arg2,arg3);
80440     } catch (std::out_of_range& e) {
80441       {
80442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80443       };
80444     } catch (std::exception& e) {
80445       {
80446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80447       };
80448     } catch (Dali::DaliException e) {
80449       {
80450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80451       };
80452     } catch (...) {
80453       {
80454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80455       };
80456     }
80457   }
80458
80459 }
80460
80461
80462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
80463   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80464   unsigned int arg2 ;
80465   float arg3 ;
80466   Dali::Toolkit::DirectionBias arg4 ;
80467
80468   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80469   arg2 = (unsigned int)jarg2;
80470   arg3 = (float)jarg3;
80471   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
80472   {
80473     try {
80474       (arg1)->ScrollTo(arg2,arg3,arg4);
80475     } catch (std::out_of_range& e) {
80476       {
80477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80478       };
80479     } catch (std::exception& e) {
80480       {
80481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80482       };
80483     } catch (Dali::DaliException e) {
80484       {
80485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80486       };
80487     } catch (...) {
80488       {
80489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80490       };
80491     }
80492   }
80493
80494 }
80495
80496
80497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
80498   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80499   Dali::Actor *arg2 = 0 ;
80500
80501   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80502   arg2 = (Dali::Actor *)jarg2;
80503   if (!arg2) {
80504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
80505     return ;
80506   }
80507   {
80508     try {
80509       (arg1)->ScrollTo(*arg2);
80510     } catch (std::out_of_range& e) {
80511       {
80512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80513       };
80514     } catch (std::exception& e) {
80515       {
80516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80517       };
80518     } catch (Dali::DaliException e) {
80519       {
80520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80521       };
80522     } catch (...) {
80523       {
80524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80525       };
80526     }
80527   }
80528
80529 }
80530
80531
80532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
80533   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80534   Dali::Actor *arg2 = 0 ;
80535   float arg3 ;
80536
80537   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80538   arg2 = (Dali::Actor *)jarg2;
80539   if (!arg2) {
80540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
80541     return ;
80542   }
80543   arg3 = (float)jarg3;
80544   {
80545     try {
80546       (arg1)->ScrollTo(*arg2,arg3);
80547     } catch (std::out_of_range& e) {
80548       {
80549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80550       };
80551     } catch (std::exception& e) {
80552       {
80553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80554       };
80555     } catch (Dali::DaliException e) {
80556       {
80557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80558       };
80559     } catch (...) {
80560       {
80561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80562       };
80563     }
80564   }
80565
80566 }
80567
80568
80569 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
80570   unsigned int jresult ;
80571   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80572   bool result;
80573
80574   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80575   {
80576     try {
80577       result = (bool)(arg1)->ScrollToSnapPoint();
80578     } catch (std::out_of_range& e) {
80579       {
80580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80581       };
80582     } catch (std::exception& e) {
80583       {
80584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80585       };
80586     } catch (Dali::DaliException e) {
80587       {
80588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80589       };
80590     } catch (...) {
80591       {
80592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80593       };
80594     }
80595   }
80596
80597   jresult = result;
80598   return jresult;
80599 }
80600
80601
80602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
80603   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80604   Dali::Constraint arg2 ;
80605   Dali::Constraint *argp2 ;
80606
80607   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80608   argp2 = (Dali::Constraint *)jarg2;
80609   if (!argp2) {
80610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
80611     return ;
80612   }
80613   arg2 = *argp2;
80614   {
80615     try {
80616       (arg1)->ApplyConstraintToChildren(arg2);
80617     } catch (std::out_of_range& e) {
80618       {
80619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80620       };
80621     } catch (std::exception& e) {
80622       {
80623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80624       };
80625     } catch (Dali::DaliException e) {
80626       {
80627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80628       };
80629     } catch (...) {
80630       {
80631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80632       };
80633     }
80634   }
80635
80636 }
80637
80638
80639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
80640   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80641
80642   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80643   {
80644     try {
80645       (arg1)->RemoveConstraintsFromChildren();
80646     } catch (std::out_of_range& e) {
80647       {
80648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80649       };
80650     } catch (std::exception& e) {
80651       {
80652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80653       };
80654     } catch (Dali::DaliException e) {
80655       {
80656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80657       };
80658     } catch (...) {
80659       {
80660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80661       };
80662     }
80663   }
80664
80665 }
80666
80667
80668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
80669   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80670   Dali::Toolkit::ScrollViewEffect arg2 ;
80671   Dali::Toolkit::ScrollViewEffect *argp2 ;
80672
80673   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80674   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
80675   if (!argp2) {
80676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
80677     return ;
80678   }
80679   arg2 = *argp2;
80680   {
80681     try {
80682       (arg1)->ApplyEffect(arg2);
80683     } catch (std::out_of_range& e) {
80684       {
80685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80686       };
80687     } catch (std::exception& e) {
80688       {
80689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80690       };
80691     } catch (Dali::DaliException e) {
80692       {
80693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80694       };
80695     } catch (...) {
80696       {
80697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80698       };
80699     }
80700   }
80701
80702 }
80703
80704
80705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
80706   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80707   Dali::Toolkit::ScrollViewEffect arg2 ;
80708   Dali::Toolkit::ScrollViewEffect *argp2 ;
80709
80710   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80711   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
80712   if (!argp2) {
80713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
80714     return ;
80715   }
80716   arg2 = *argp2;
80717   {
80718     try {
80719       (arg1)->RemoveEffect(arg2);
80720     } catch (std::out_of_range& e) {
80721       {
80722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80723       };
80724     } catch (std::exception& e) {
80725       {
80726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80727       };
80728     } catch (Dali::DaliException e) {
80729       {
80730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80731       };
80732     } catch (...) {
80733       {
80734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80735       };
80736     }
80737   }
80738
80739 }
80740
80741
80742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
80743   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80744
80745   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80746   {
80747     try {
80748       (arg1)->RemoveAllEffects();
80749     } catch (std::out_of_range& e) {
80750       {
80751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80752       };
80753     } catch (std::exception& e) {
80754       {
80755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80756       };
80757     } catch (Dali::DaliException e) {
80758       {
80759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80760       };
80761     } catch (...) {
80762       {
80763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80764       };
80765     }
80766   }
80767
80768 }
80769
80770
80771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
80772   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80773   Dali::Actor arg2 ;
80774   Dali::Actor *argp2 ;
80775
80776   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80777   argp2 = (Dali::Actor *)jarg2;
80778   if (!argp2) {
80779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80780     return ;
80781   }
80782   arg2 = *argp2;
80783   {
80784     try {
80785       (arg1)->BindActor(arg2);
80786     } catch (std::out_of_range& e) {
80787       {
80788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80789       };
80790     } catch (std::exception& e) {
80791       {
80792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80793       };
80794     } catch (Dali::DaliException e) {
80795       {
80796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80797       };
80798     } catch (...) {
80799       {
80800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80801       };
80802     }
80803   }
80804
80805 }
80806
80807
80808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
80809   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80810   Dali::Actor arg2 ;
80811   Dali::Actor *argp2 ;
80812
80813   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80814   argp2 = (Dali::Actor *)jarg2;
80815   if (!argp2) {
80816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80817     return ;
80818   }
80819   arg2 = *argp2;
80820   {
80821     try {
80822       (arg1)->UnbindActor(arg2);
80823     } catch (std::out_of_range& e) {
80824       {
80825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80826       };
80827     } catch (std::exception& e) {
80828       {
80829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80830       };
80831     } catch (Dali::DaliException e) {
80832       {
80833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80834       };
80835     } catch (...) {
80836       {
80837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80838       };
80839     }
80840   }
80841
80842 }
80843
80844
80845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
80846   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80847   Dali::Radian arg2 ;
80848   Dali::Radian arg3 ;
80849   Dali::Radian *argp2 ;
80850   Dali::Radian *argp3 ;
80851
80852   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80853   argp2 = (Dali::Radian *)jarg2;
80854   if (!argp2) {
80855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80856     return ;
80857   }
80858   arg2 = *argp2;
80859   argp3 = (Dali::Radian *)jarg3;
80860   if (!argp3) {
80861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80862     return ;
80863   }
80864   arg3 = *argp3;
80865   {
80866     try {
80867       (arg1)->SetScrollingDirection(arg2,arg3);
80868     } catch (std::out_of_range& e) {
80869       {
80870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80871       };
80872     } catch (std::exception& e) {
80873       {
80874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80875       };
80876     } catch (Dali::DaliException e) {
80877       {
80878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80879       };
80880     } catch (...) {
80881       {
80882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80883       };
80884     }
80885   }
80886
80887 }
80888
80889
80890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
80891   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80892   Dali::Radian arg2 ;
80893   Dali::Radian *argp2 ;
80894
80895   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80896   argp2 = (Dali::Radian *)jarg2;
80897   if (!argp2) {
80898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80899     return ;
80900   }
80901   arg2 = *argp2;
80902   {
80903     try {
80904       (arg1)->SetScrollingDirection(arg2);
80905     } catch (std::out_of_range& e) {
80906       {
80907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80908       };
80909     } catch (std::exception& e) {
80910       {
80911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80912       };
80913     } catch (Dali::DaliException e) {
80914       {
80915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80916       };
80917     } catch (...) {
80918       {
80919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80920       };
80921     }
80922   }
80923
80924 }
80925
80926
80927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
80928   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80929   Dali::Radian arg2 ;
80930   Dali::Radian *argp2 ;
80931
80932   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80933   argp2 = (Dali::Radian *)jarg2;
80934   if (!argp2) {
80935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80936     return ;
80937   }
80938   arg2 = *argp2;
80939   {
80940     try {
80941       (arg1)->RemoveScrollingDirection(arg2);
80942     } catch (std::out_of_range& e) {
80943       {
80944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80945       };
80946     } catch (std::exception& e) {
80947       {
80948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80949       };
80950     } catch (Dali::DaliException e) {
80951       {
80952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80953       };
80954     } catch (...) {
80955       {
80956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80957       };
80958     }
80959   }
80960
80961 }
80962
80963
80964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
80965   void * jresult ;
80966   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80967   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
80968
80969   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80970   {
80971     try {
80972       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
80973     } catch (std::out_of_range& e) {
80974       {
80975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80976       };
80977     } catch (std::exception& e) {
80978       {
80979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80980       };
80981     } catch (Dali::DaliException e) {
80982       {
80983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80984       };
80985     } catch (...) {
80986       {
80987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80988       };
80989     }
80990   }
80991
80992   jresult = (void *)result;
80993   return jresult;
80994 }
80995
80996
80997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
80998   int jresult ;
80999   int result;
81000
81001   result = (int)Dali::Toolkit::TableView::Property::ROWS;
81002   jresult = (int)result;
81003   return jresult;
81004 }
81005
81006
81007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
81008   int jresult ;
81009   int result;
81010
81011   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
81012   jresult = (int)result;
81013   return jresult;
81014 }
81015
81016
81017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
81018   int jresult ;
81019   int result;
81020
81021   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
81022   jresult = (int)result;
81023   return jresult;
81024 }
81025
81026
81027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
81028   int jresult ;
81029   int result;
81030
81031   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
81032   jresult = (int)result;
81033   return jresult;
81034 }
81035
81036
81037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
81038   int jresult ;
81039   int result;
81040
81041   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
81042   jresult = (int)result;
81043   return jresult;
81044 }
81045
81046
81047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
81048   void * jresult ;
81049   Dali::Toolkit::TableView::Property *result = 0 ;
81050
81051   {
81052     try {
81053       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
81054     } catch (std::out_of_range& e) {
81055       {
81056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81057       };
81058     } catch (std::exception& e) {
81059       {
81060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81061       };
81062     } catch (Dali::DaliException e) {
81063       {
81064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81065       };
81066     } catch (...) {
81067       {
81068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81069       };
81070     }
81071   }
81072
81073   jresult = (void *)result;
81074   return jresult;
81075 }
81076
81077
81078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
81079   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
81080
81081   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
81082   {
81083     try {
81084       delete arg1;
81085     } catch (std::out_of_range& e) {
81086       {
81087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81088       };
81089     } catch (std::exception& e) {
81090       {
81091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81092       };
81093     } catch (Dali::DaliException e) {
81094       {
81095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81096       };
81097     } catch (...) {
81098       {
81099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81100       };
81101     }
81102   }
81103
81104 }
81105
81106
81107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
81108   int jresult ;
81109   int result;
81110
81111   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
81112   jresult = (int)result;
81113   return jresult;
81114 }
81115
81116
81117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
81118   int jresult ;
81119   int result;
81120
81121   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
81122   jresult = (int)result;
81123   return jresult;
81124 }
81125
81126
81127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
81128   int jresult ;
81129   int result;
81130
81131   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
81132   jresult = (int)result;
81133   return jresult;
81134 }
81135
81136
81137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
81138   int jresult ;
81139   int result;
81140
81141   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
81142   jresult = (int)result;
81143   return jresult;
81144 }
81145
81146
81147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
81148   int jresult ;
81149   int result;
81150
81151   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
81152   jresult = (int)result;
81153   return jresult;
81154 }
81155
81156
81157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
81158   void * jresult ;
81159   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
81160
81161   {
81162     try {
81163       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
81164     } catch (std::out_of_range& e) {
81165       {
81166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81167       };
81168     } catch (std::exception& e) {
81169       {
81170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81171       };
81172     } catch (Dali::DaliException e) {
81173       {
81174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81175       };
81176     } catch (...) {
81177       {
81178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81179       };
81180     }
81181   }
81182
81183   jresult = (void *)result;
81184   return jresult;
81185 }
81186
81187
81188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
81189   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
81190
81191   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
81192   {
81193     try {
81194       delete arg1;
81195     } catch (std::out_of_range& e) {
81196       {
81197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81198       };
81199     } catch (std::exception& e) {
81200       {
81201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81202       };
81203     } catch (Dali::DaliException e) {
81204       {
81205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81206       };
81207     } catch (...) {
81208       {
81209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81210       };
81211     }
81212   }
81213
81214 }
81215
81216
81217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
81218   void * jresult ;
81219   unsigned int arg1 ;
81220   unsigned int arg2 ;
81221   unsigned int arg3 ;
81222   unsigned int arg4 ;
81223   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81224
81225   arg1 = (unsigned int)jarg1;
81226   arg2 = (unsigned int)jarg2;
81227   arg3 = (unsigned int)jarg3;
81228   arg4 = (unsigned int)jarg4;
81229   {
81230     try {
81231       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
81232     } catch (std::out_of_range& e) {
81233       {
81234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81235       };
81236     } catch (std::exception& e) {
81237       {
81238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81239       };
81240     } catch (Dali::DaliException e) {
81241       {
81242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81243       };
81244     } catch (...) {
81245       {
81246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81247       };
81248     }
81249   }
81250
81251   jresult = (void *)result;
81252   return jresult;
81253 }
81254
81255
81256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
81257   void * jresult ;
81258   unsigned int arg1 ;
81259   unsigned int arg2 ;
81260   unsigned int arg3 ;
81261   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81262
81263   arg1 = (unsigned int)jarg1;
81264   arg2 = (unsigned int)jarg2;
81265   arg3 = (unsigned int)jarg3;
81266   {
81267     try {
81268       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
81269     } catch (std::out_of_range& e) {
81270       {
81271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81272       };
81273     } catch (std::exception& e) {
81274       {
81275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81276       };
81277     } catch (Dali::DaliException e) {
81278       {
81279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81280       };
81281     } catch (...) {
81282       {
81283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81284       };
81285     }
81286   }
81287
81288   jresult = (void *)result;
81289   return jresult;
81290 }
81291
81292
81293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
81294   void * jresult ;
81295   unsigned int arg1 ;
81296   unsigned int arg2 ;
81297   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81298
81299   arg1 = (unsigned int)jarg1;
81300   arg2 = (unsigned int)jarg2;
81301   {
81302     try {
81303       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
81304     } catch (std::out_of_range& e) {
81305       {
81306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81307       };
81308     } catch (std::exception& e) {
81309       {
81310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81311       };
81312     } catch (Dali::DaliException e) {
81313       {
81314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81315       };
81316     } catch (...) {
81317       {
81318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81319       };
81320     }
81321   }
81322
81323   jresult = (void *)result;
81324   return jresult;
81325 }
81326
81327
81328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
81329   void * jresult ;
81330   unsigned int arg1 ;
81331   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81332
81333   arg1 = (unsigned int)jarg1;
81334   {
81335     try {
81336       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
81337     } catch (std::out_of_range& e) {
81338       {
81339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81340       };
81341     } catch (std::exception& e) {
81342       {
81343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81344       };
81345     } catch (Dali::DaliException e) {
81346       {
81347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81348       };
81349     } catch (...) {
81350       {
81351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81352       };
81353     }
81354   }
81355
81356   jresult = (void *)result;
81357   return jresult;
81358 }
81359
81360
81361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
81362   void * jresult ;
81363   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81364
81365   {
81366     try {
81367       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
81368     } catch (std::out_of_range& e) {
81369       {
81370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81371       };
81372     } catch (std::exception& e) {
81373       {
81374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81375       };
81376     } catch (Dali::DaliException e) {
81377       {
81378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81379       };
81380     } catch (...) {
81381       {
81382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81383       };
81384     }
81385   }
81386
81387   jresult = (void *)result;
81388   return jresult;
81389 }
81390
81391
81392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
81393   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81394   unsigned int arg2 ;
81395
81396   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81397   arg2 = (unsigned int)jarg2;
81398   if (arg1) (arg1)->rowIndex = arg2;
81399 }
81400
81401
81402 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
81403   unsigned int jresult ;
81404   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81405   unsigned int result;
81406
81407   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81408   result = (unsigned int) ((arg1)->rowIndex);
81409   jresult = result;
81410   return jresult;
81411 }
81412
81413
81414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
81415   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81416   unsigned int arg2 ;
81417
81418   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81419   arg2 = (unsigned int)jarg2;
81420   if (arg1) (arg1)->columnIndex = arg2;
81421 }
81422
81423
81424 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
81425   unsigned int jresult ;
81426   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81427   unsigned int result;
81428
81429   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81430   result = (unsigned int) ((arg1)->columnIndex);
81431   jresult = result;
81432   return jresult;
81433 }
81434
81435
81436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
81437   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81438   unsigned int arg2 ;
81439
81440   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81441   arg2 = (unsigned int)jarg2;
81442   if (arg1) (arg1)->rowSpan = arg2;
81443 }
81444
81445
81446 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
81447   unsigned int jresult ;
81448   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81449   unsigned int result;
81450
81451   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81452   result = (unsigned int) ((arg1)->rowSpan);
81453   jresult = result;
81454   return jresult;
81455 }
81456
81457
81458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
81459   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81460   unsigned int arg2 ;
81461
81462   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81463   arg2 = (unsigned int)jarg2;
81464   if (arg1) (arg1)->columnSpan = arg2;
81465 }
81466
81467
81468 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
81469   unsigned int jresult ;
81470   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81471   unsigned int result;
81472
81473   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81474   result = (unsigned int) ((arg1)->columnSpan);
81475   jresult = result;
81476   return jresult;
81477 }
81478
81479
81480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
81481   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81482
81483   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81484   {
81485     try {
81486       delete arg1;
81487     } catch (std::out_of_range& e) {
81488       {
81489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81490       };
81491     } catch (std::exception& e) {
81492       {
81493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81494       };
81495     } catch (Dali::DaliException e) {
81496       {
81497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81498       };
81499     } catch (...) {
81500       {
81501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81502       };
81503     }
81504   }
81505
81506 }
81507
81508
81509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
81510   void * jresult ;
81511   Dali::Toolkit::TableView *result = 0 ;
81512
81513   {
81514     try {
81515       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
81516     } catch (std::out_of_range& e) {
81517       {
81518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81519       };
81520     } catch (std::exception& e) {
81521       {
81522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81523       };
81524     } catch (Dali::DaliException e) {
81525       {
81526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81527       };
81528     } catch (...) {
81529       {
81530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81531       };
81532     }
81533   }
81534
81535   jresult = (void *)result;
81536   return jresult;
81537 }
81538
81539
81540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
81541   void * jresult ;
81542   Dali::Toolkit::TableView *arg1 = 0 ;
81543   Dali::Toolkit::TableView *result = 0 ;
81544
81545   arg1 = (Dali::Toolkit::TableView *)jarg1;
81546   if (!arg1) {
81547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
81548     return 0;
81549   }
81550   {
81551     try {
81552       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
81553     } catch (std::out_of_range& e) {
81554       {
81555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81556       };
81557     } catch (std::exception& e) {
81558       {
81559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81560       };
81561     } catch (Dali::DaliException e) {
81562       {
81563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81564       };
81565     } catch (...) {
81566       {
81567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81568       };
81569     }
81570   }
81571
81572   jresult = (void *)result;
81573   return jresult;
81574 }
81575
81576
81577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
81578   void * jresult ;
81579   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81580   Dali::Toolkit::TableView *arg2 = 0 ;
81581   Dali::Toolkit::TableView *result = 0 ;
81582
81583   arg1 = (Dali::Toolkit::TableView *)jarg1;
81584   arg2 = (Dali::Toolkit::TableView *)jarg2;
81585   if (!arg2) {
81586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
81587     return 0;
81588   }
81589   {
81590     try {
81591       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
81592     } catch (std::out_of_range& e) {
81593       {
81594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81595       };
81596     } catch (std::exception& e) {
81597       {
81598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81599       };
81600     } catch (Dali::DaliException e) {
81601       {
81602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81603       };
81604     } catch (...) {
81605       {
81606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81607       };
81608     }
81609   }
81610
81611   jresult = (void *)result;
81612   return jresult;
81613 }
81614
81615
81616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
81617   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81618
81619   arg1 = (Dali::Toolkit::TableView *)jarg1;
81620   {
81621     try {
81622       delete arg1;
81623     } catch (std::out_of_range& e) {
81624       {
81625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81626       };
81627     } catch (std::exception& e) {
81628       {
81629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81630       };
81631     } catch (Dali::DaliException e) {
81632       {
81633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81634       };
81635     } catch (...) {
81636       {
81637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81638       };
81639     }
81640   }
81641
81642 }
81643
81644
81645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
81646   void * jresult ;
81647   unsigned int arg1 ;
81648   unsigned int arg2 ;
81649   Dali::Toolkit::TableView result;
81650
81651   arg1 = (unsigned int)jarg1;
81652   arg2 = (unsigned int)jarg2;
81653   {
81654     try {
81655       result = Dali::Toolkit::TableView::New(arg1,arg2);
81656     } catch (std::out_of_range& e) {
81657       {
81658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81659       };
81660     } catch (std::exception& e) {
81661       {
81662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81663       };
81664     } catch (Dali::DaliException e) {
81665       {
81666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81667       };
81668     } catch (...) {
81669       {
81670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81671       };
81672     }
81673   }
81674
81675   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
81676   return jresult;
81677 }
81678
81679
81680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
81681   void * jresult ;
81682   Dali::BaseHandle arg1 ;
81683   Dali::BaseHandle *argp1 ;
81684   Dali::Toolkit::TableView result;
81685
81686   argp1 = (Dali::BaseHandle *)jarg1;
81687   if (!argp1) {
81688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81689     return 0;
81690   }
81691   arg1 = *argp1;
81692   {
81693     try {
81694       result = Dali::Toolkit::TableView::DownCast(arg1);
81695     } catch (std::out_of_range& e) {
81696       {
81697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81698       };
81699     } catch (std::exception& e) {
81700       {
81701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81702       };
81703     } catch (Dali::DaliException e) {
81704       {
81705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81706       };
81707     } catch (...) {
81708       {
81709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81710       };
81711     }
81712   }
81713
81714   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
81715   return jresult;
81716 }
81717
81718
81719 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
81720   unsigned int jresult ;
81721   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81722   Dali::Actor arg2 ;
81723   Dali::Toolkit::TableView::CellPosition arg3 ;
81724   Dali::Actor *argp2 ;
81725   Dali::Toolkit::TableView::CellPosition *argp3 ;
81726   bool result;
81727
81728   arg1 = (Dali::Toolkit::TableView *)jarg1;
81729   argp2 = (Dali::Actor *)jarg2;
81730   if (!argp2) {
81731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81732     return 0;
81733   }
81734   arg2 = *argp2;
81735   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
81736   if (!argp3) {
81737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
81738     return 0;
81739   }
81740   arg3 = *argp3;
81741   {
81742     try {
81743       result = (bool)(arg1)->AddChild(arg2,arg3);
81744     } catch (std::out_of_range& e) {
81745       {
81746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81747       };
81748     } catch (std::exception& e) {
81749       {
81750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81751       };
81752     } catch (Dali::DaliException e) {
81753       {
81754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81755       };
81756     } catch (...) {
81757       {
81758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81759       };
81760     }
81761   }
81762
81763   jresult = result;
81764   return jresult;
81765 }
81766
81767
81768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
81769   void * jresult ;
81770   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81771   Dali::Toolkit::TableView::CellPosition arg2 ;
81772   Dali::Toolkit::TableView::CellPosition *argp2 ;
81773   Dali::Actor result;
81774
81775   arg1 = (Dali::Toolkit::TableView *)jarg1;
81776   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
81777   if (!argp2) {
81778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
81779     return 0;
81780   }
81781   arg2 = *argp2;
81782   {
81783     try {
81784       result = (arg1)->GetChildAt(arg2);
81785     } catch (std::out_of_range& e) {
81786       {
81787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81788       };
81789     } catch (std::exception& e) {
81790       {
81791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81792       };
81793     } catch (Dali::DaliException e) {
81794       {
81795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81796       };
81797     } catch (...) {
81798       {
81799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81800       };
81801     }
81802   }
81803
81804   jresult = new Dali::Actor((const Dali::Actor &)result);
81805   return jresult;
81806 }
81807
81808
81809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
81810   void * jresult ;
81811   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81812   Dali::Toolkit::TableView::CellPosition arg2 ;
81813   Dali::Toolkit::TableView::CellPosition *argp2 ;
81814   Dali::Actor result;
81815
81816   arg1 = (Dali::Toolkit::TableView *)jarg1;
81817   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
81818   if (!argp2) {
81819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
81820     return 0;
81821   }
81822   arg2 = *argp2;
81823   {
81824     try {
81825       result = (arg1)->RemoveChildAt(arg2);
81826     } catch (std::out_of_range& e) {
81827       {
81828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81829       };
81830     } catch (std::exception& e) {
81831       {
81832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81833       };
81834     } catch (Dali::DaliException e) {
81835       {
81836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81837       };
81838     } catch (...) {
81839       {
81840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81841       };
81842     }
81843   }
81844
81845   jresult = new Dali::Actor((const Dali::Actor &)result);
81846   return jresult;
81847 }
81848
81849
81850 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
81851   unsigned int jresult ;
81852   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81853   Dali::Actor arg2 ;
81854   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
81855   Dali::Actor *argp2 ;
81856   bool result;
81857
81858   arg1 = (Dali::Toolkit::TableView *)jarg1;
81859   argp2 = (Dali::Actor *)jarg2;
81860   if (!argp2) {
81861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81862     return 0;
81863   }
81864   arg2 = *argp2;
81865   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
81866   if (!arg3) {
81867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
81868     return 0;
81869   }
81870   {
81871     try {
81872       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
81873     } catch (std::out_of_range& e) {
81874       {
81875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81876       };
81877     } catch (std::exception& e) {
81878       {
81879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81880       };
81881     } catch (Dali::DaliException e) {
81882       {
81883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81884       };
81885     } catch (...) {
81886       {
81887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81888       };
81889     }
81890   }
81891
81892   jresult = result;
81893   return jresult;
81894 }
81895
81896
81897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
81898   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81899   unsigned int arg2 ;
81900
81901   arg1 = (Dali::Toolkit::TableView *)jarg1;
81902   arg2 = (unsigned int)jarg2;
81903   {
81904     try {
81905       (arg1)->InsertRow(arg2);
81906     } catch (std::out_of_range& e) {
81907       {
81908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81909       };
81910     } catch (std::exception& e) {
81911       {
81912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81913       };
81914     } catch (Dali::DaliException e) {
81915       {
81916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81917       };
81918     } catch (...) {
81919       {
81920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81921       };
81922     }
81923   }
81924
81925 }
81926
81927
81928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
81929   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81930   unsigned int arg2 ;
81931
81932   arg1 = (Dali::Toolkit::TableView *)jarg1;
81933   arg2 = (unsigned int)jarg2;
81934   {
81935     try {
81936       (arg1)->DeleteRow(arg2);
81937     } catch (std::out_of_range& e) {
81938       {
81939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81940       };
81941     } catch (std::exception& e) {
81942       {
81943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81944       };
81945     } catch (Dali::DaliException e) {
81946       {
81947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81948       };
81949     } catch (...) {
81950       {
81951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81952       };
81953     }
81954   }
81955
81956 }
81957
81958
81959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
81960   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81961   unsigned int arg2 ;
81962   std::vector< Dali::Actor > *arg3 = 0 ;
81963
81964   arg1 = (Dali::Toolkit::TableView *)jarg1;
81965   arg2 = (unsigned int)jarg2;
81966   arg3 = (std::vector< Dali::Actor > *)jarg3;
81967   if (!arg3) {
81968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
81969     return ;
81970   }
81971   {
81972     try {
81973       (arg1)->DeleteRow(arg2,*arg3);
81974     } catch (std::out_of_range& e) {
81975       {
81976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81977       };
81978     } catch (std::exception& e) {
81979       {
81980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81981       };
81982     } catch (Dali::DaliException e) {
81983       {
81984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81985       };
81986     } catch (...) {
81987       {
81988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81989       };
81990     }
81991   }
81992
81993 }
81994
81995
81996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
81997   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81998   unsigned int arg2 ;
81999
82000   arg1 = (Dali::Toolkit::TableView *)jarg1;
82001   arg2 = (unsigned int)jarg2;
82002   {
82003     try {
82004       (arg1)->InsertColumn(arg2);
82005     } catch (std::out_of_range& e) {
82006       {
82007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82008       };
82009     } catch (std::exception& e) {
82010       {
82011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82012       };
82013     } catch (Dali::DaliException e) {
82014       {
82015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82016       };
82017     } catch (...) {
82018       {
82019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82020       };
82021     }
82022   }
82023
82024 }
82025
82026
82027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
82028   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82029   unsigned int arg2 ;
82030
82031   arg1 = (Dali::Toolkit::TableView *)jarg1;
82032   arg2 = (unsigned int)jarg2;
82033   {
82034     try {
82035       (arg1)->DeleteColumn(arg2);
82036     } catch (std::out_of_range& e) {
82037       {
82038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82039       };
82040     } catch (std::exception& e) {
82041       {
82042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82043       };
82044     } catch (Dali::DaliException e) {
82045       {
82046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82047       };
82048     } catch (...) {
82049       {
82050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82051       };
82052     }
82053   }
82054
82055 }
82056
82057
82058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
82059   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82060   unsigned int arg2 ;
82061   std::vector< Dali::Actor > *arg3 = 0 ;
82062
82063   arg1 = (Dali::Toolkit::TableView *)jarg1;
82064   arg2 = (unsigned int)jarg2;
82065   arg3 = (std::vector< Dali::Actor > *)jarg3;
82066   if (!arg3) {
82067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
82068     return ;
82069   }
82070   {
82071     try {
82072       (arg1)->DeleteColumn(arg2,*arg3);
82073     } catch (std::out_of_range& e) {
82074       {
82075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82076       };
82077     } catch (std::exception& e) {
82078       {
82079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82080       };
82081     } catch (Dali::DaliException e) {
82082       {
82083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82084       };
82085     } catch (...) {
82086       {
82087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82088       };
82089     }
82090   }
82091
82092 }
82093
82094
82095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
82096   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82097   unsigned int arg2 ;
82098   unsigned int arg3 ;
82099
82100   arg1 = (Dali::Toolkit::TableView *)jarg1;
82101   arg2 = (unsigned int)jarg2;
82102   arg3 = (unsigned int)jarg3;
82103   {
82104     try {
82105       (arg1)->Resize(arg2,arg3);
82106     } catch (std::out_of_range& e) {
82107       {
82108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82109       };
82110     } catch (std::exception& e) {
82111       {
82112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82113       };
82114     } catch (Dali::DaliException e) {
82115       {
82116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82117       };
82118     } catch (...) {
82119       {
82120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82121       };
82122     }
82123   }
82124
82125 }
82126
82127
82128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
82129   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82130   unsigned int arg2 ;
82131   unsigned int arg3 ;
82132   std::vector< Dali::Actor > *arg4 = 0 ;
82133
82134   arg1 = (Dali::Toolkit::TableView *)jarg1;
82135   arg2 = (unsigned int)jarg2;
82136   arg3 = (unsigned int)jarg3;
82137   arg4 = (std::vector< Dali::Actor > *)jarg4;
82138   if (!arg4) {
82139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
82140     return ;
82141   }
82142   {
82143     try {
82144       (arg1)->Resize(arg2,arg3,*arg4);
82145     } catch (std::out_of_range& e) {
82146       {
82147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82148       };
82149     } catch (std::exception& e) {
82150       {
82151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82152       };
82153     } catch (Dali::DaliException e) {
82154       {
82155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82156       };
82157     } catch (...) {
82158       {
82159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82160       };
82161     }
82162   }
82163
82164 }
82165
82166
82167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
82168   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82169   Dali::Size arg2 ;
82170   Dali::Size *argp2 ;
82171
82172   arg1 = (Dali::Toolkit::TableView *)jarg1;
82173   argp2 = (Dali::Size *)jarg2;
82174   if (!argp2) {
82175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
82176     return ;
82177   }
82178   arg2 = *argp2;
82179   {
82180     try {
82181       (arg1)->SetCellPadding(arg2);
82182     } catch (std::out_of_range& e) {
82183       {
82184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82185       };
82186     } catch (std::exception& e) {
82187       {
82188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82189       };
82190     } catch (Dali::DaliException e) {
82191       {
82192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82193       };
82194     } catch (...) {
82195       {
82196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82197       };
82198     }
82199   }
82200
82201 }
82202
82203
82204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
82205   void * jresult ;
82206   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82207   Dali::Size result;
82208
82209   arg1 = (Dali::Toolkit::TableView *)jarg1;
82210   {
82211     try {
82212       result = (arg1)->GetCellPadding();
82213     } catch (std::out_of_range& e) {
82214       {
82215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82216       };
82217     } catch (std::exception& e) {
82218       {
82219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82220       };
82221     } catch (Dali::DaliException e) {
82222       {
82223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82224       };
82225     } catch (...) {
82226       {
82227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82228       };
82229     }
82230   }
82231
82232   jresult = new Dali::Size((const Dali::Size &)result);
82233   return jresult;
82234 }
82235
82236
82237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
82238   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82239   unsigned int arg2 ;
82240
82241   arg1 = (Dali::Toolkit::TableView *)jarg1;
82242   arg2 = (unsigned int)jarg2;
82243   {
82244     try {
82245       (arg1)->SetFitHeight(arg2);
82246     } catch (std::out_of_range& e) {
82247       {
82248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82249       };
82250     } catch (std::exception& e) {
82251       {
82252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82253       };
82254     } catch (Dali::DaliException e) {
82255       {
82256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82257       };
82258     } catch (...) {
82259       {
82260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82261       };
82262     }
82263   }
82264
82265 }
82266
82267
82268 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
82269   unsigned int jresult ;
82270   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82271   unsigned int arg2 ;
82272   bool result;
82273
82274   arg1 = (Dali::Toolkit::TableView *)jarg1;
82275   arg2 = (unsigned int)jarg2;
82276   {
82277     try {
82278       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
82279     } catch (std::out_of_range& e) {
82280       {
82281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82282       };
82283     } catch (std::exception& e) {
82284       {
82285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82286       };
82287     } catch (Dali::DaliException e) {
82288       {
82289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82290       };
82291     } catch (...) {
82292       {
82293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82294       };
82295     }
82296   }
82297
82298   jresult = result;
82299   return jresult;
82300 }
82301
82302
82303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
82304   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82305   unsigned int arg2 ;
82306
82307   arg1 = (Dali::Toolkit::TableView *)jarg1;
82308   arg2 = (unsigned int)jarg2;
82309   {
82310     try {
82311       (arg1)->SetFitWidth(arg2);
82312     } catch (std::out_of_range& e) {
82313       {
82314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82315       };
82316     } catch (std::exception& e) {
82317       {
82318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82319       };
82320     } catch (Dali::DaliException e) {
82321       {
82322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82323       };
82324     } catch (...) {
82325       {
82326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82327       };
82328     }
82329   }
82330
82331 }
82332
82333
82334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
82335   unsigned int jresult ;
82336   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82337   unsigned int arg2 ;
82338   bool result;
82339
82340   arg1 = (Dali::Toolkit::TableView *)jarg1;
82341   arg2 = (unsigned int)jarg2;
82342   {
82343     try {
82344       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
82345     } catch (std::out_of_range& e) {
82346       {
82347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82348       };
82349     } catch (std::exception& e) {
82350       {
82351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82352       };
82353     } catch (Dali::DaliException e) {
82354       {
82355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82356       };
82357     } catch (...) {
82358       {
82359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82360       };
82361     }
82362   }
82363
82364   jresult = result;
82365   return jresult;
82366 }
82367
82368
82369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
82370   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82371   unsigned int arg2 ;
82372   float arg3 ;
82373
82374   arg1 = (Dali::Toolkit::TableView *)jarg1;
82375   arg2 = (unsigned int)jarg2;
82376   arg3 = (float)jarg3;
82377   {
82378     try {
82379       (arg1)->SetFixedHeight(arg2,arg3);
82380     } catch (std::out_of_range& e) {
82381       {
82382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82383       };
82384     } catch (std::exception& e) {
82385       {
82386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82387       };
82388     } catch (Dali::DaliException e) {
82389       {
82390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82391       };
82392     } catch (...) {
82393       {
82394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82395       };
82396     }
82397   }
82398
82399 }
82400
82401
82402 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
82403   float jresult ;
82404   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82405   unsigned int arg2 ;
82406   float result;
82407
82408   arg1 = (Dali::Toolkit::TableView *)jarg1;
82409   arg2 = (unsigned int)jarg2;
82410   {
82411     try {
82412       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
82413     } catch (std::out_of_range& e) {
82414       {
82415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82416       };
82417     } catch (std::exception& e) {
82418       {
82419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82420       };
82421     } catch (Dali::DaliException e) {
82422       {
82423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82424       };
82425     } catch (...) {
82426       {
82427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82428       };
82429     }
82430   }
82431
82432   jresult = result;
82433   return jresult;
82434 }
82435
82436
82437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
82438   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82439   unsigned int arg2 ;
82440   float arg3 ;
82441
82442   arg1 = (Dali::Toolkit::TableView *)jarg1;
82443   arg2 = (unsigned int)jarg2;
82444   arg3 = (float)jarg3;
82445   {
82446     try {
82447       (arg1)->SetRelativeHeight(arg2,arg3);
82448     } catch (std::out_of_range& e) {
82449       {
82450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82451       };
82452     } catch (std::exception& e) {
82453       {
82454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82455       };
82456     } catch (Dali::DaliException e) {
82457       {
82458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82459       };
82460     } catch (...) {
82461       {
82462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82463       };
82464     }
82465   }
82466
82467 }
82468
82469
82470 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
82471   float jresult ;
82472   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82473   unsigned int arg2 ;
82474   float result;
82475
82476   arg1 = (Dali::Toolkit::TableView *)jarg1;
82477   arg2 = (unsigned int)jarg2;
82478   {
82479     try {
82480       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
82481     } catch (std::out_of_range& e) {
82482       {
82483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82484       };
82485     } catch (std::exception& e) {
82486       {
82487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82488       };
82489     } catch (Dali::DaliException e) {
82490       {
82491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82492       };
82493     } catch (...) {
82494       {
82495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82496       };
82497     }
82498   }
82499
82500   jresult = result;
82501   return jresult;
82502 }
82503
82504
82505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
82506   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82507   unsigned int arg2 ;
82508   float arg3 ;
82509
82510   arg1 = (Dali::Toolkit::TableView *)jarg1;
82511   arg2 = (unsigned int)jarg2;
82512   arg3 = (float)jarg3;
82513   {
82514     try {
82515       (arg1)->SetFixedWidth(arg2,arg3);
82516     } catch (std::out_of_range& e) {
82517       {
82518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82519       };
82520     } catch (std::exception& e) {
82521       {
82522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82523       };
82524     } catch (Dali::DaliException e) {
82525       {
82526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82527       };
82528     } catch (...) {
82529       {
82530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82531       };
82532     }
82533   }
82534
82535 }
82536
82537
82538 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
82539   float jresult ;
82540   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82541   unsigned int arg2 ;
82542   float result;
82543
82544   arg1 = (Dali::Toolkit::TableView *)jarg1;
82545   arg2 = (unsigned int)jarg2;
82546   {
82547     try {
82548       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
82549     } catch (std::out_of_range& e) {
82550       {
82551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82552       };
82553     } catch (std::exception& e) {
82554       {
82555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82556       };
82557     } catch (Dali::DaliException e) {
82558       {
82559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82560       };
82561     } catch (...) {
82562       {
82563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82564       };
82565     }
82566   }
82567
82568   jresult = result;
82569   return jresult;
82570 }
82571
82572
82573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
82574   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82575   unsigned int arg2 ;
82576   float arg3 ;
82577
82578   arg1 = (Dali::Toolkit::TableView *)jarg1;
82579   arg2 = (unsigned int)jarg2;
82580   arg3 = (float)jarg3;
82581   {
82582     try {
82583       (arg1)->SetRelativeWidth(arg2,arg3);
82584     } catch (std::out_of_range& e) {
82585       {
82586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82587       };
82588     } catch (std::exception& e) {
82589       {
82590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82591       };
82592     } catch (Dali::DaliException e) {
82593       {
82594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82595       };
82596     } catch (...) {
82597       {
82598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82599       };
82600     }
82601   }
82602
82603 }
82604
82605
82606 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
82607   float jresult ;
82608   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82609   unsigned int arg2 ;
82610   float result;
82611
82612   arg1 = (Dali::Toolkit::TableView *)jarg1;
82613   arg2 = (unsigned int)jarg2;
82614   {
82615     try {
82616       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
82617     } catch (std::out_of_range& e) {
82618       {
82619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82620       };
82621     } catch (std::exception& e) {
82622       {
82623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82624       };
82625     } catch (Dali::DaliException e) {
82626       {
82627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82628       };
82629     } catch (...) {
82630       {
82631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82632       };
82633     }
82634   }
82635
82636   jresult = result;
82637   return jresult;
82638 }
82639
82640
82641 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
82642   unsigned int jresult ;
82643   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82644   unsigned int result;
82645
82646   arg1 = (Dali::Toolkit::TableView *)jarg1;
82647   {
82648     try {
82649       result = (unsigned int)(arg1)->GetRows();
82650     } catch (std::out_of_range& e) {
82651       {
82652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82653       };
82654     } catch (std::exception& e) {
82655       {
82656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82657       };
82658     } catch (Dali::DaliException e) {
82659       {
82660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82661       };
82662     } catch (...) {
82663       {
82664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82665       };
82666     }
82667   }
82668
82669   jresult = result;
82670   return jresult;
82671 }
82672
82673
82674 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
82675   unsigned int jresult ;
82676   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82677   unsigned int result;
82678
82679   arg1 = (Dali::Toolkit::TableView *)jarg1;
82680   {
82681     try {
82682       result = (unsigned int)(arg1)->GetColumns();
82683     } catch (std::out_of_range& e) {
82684       {
82685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82686       };
82687     } catch (std::exception& e) {
82688       {
82689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82690       };
82691     } catch (Dali::DaliException e) {
82692       {
82693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82694       };
82695     } catch (...) {
82696       {
82697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82698       };
82699     }
82700   }
82701
82702   jresult = result;
82703   return jresult;
82704 }
82705
82706
82707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
82708   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82709   Dali::Toolkit::TableView::CellPosition arg2 ;
82710   Dali::HorizontalAlignment::Type arg3 ;
82711   Dali::VerticalAlignment::Type arg4 ;
82712   Dali::Toolkit::TableView::CellPosition *argp2 ;
82713
82714   arg1 = (Dali::Toolkit::TableView *)jarg1;
82715   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82716   if (!argp2) {
82717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82718     return ;
82719   }
82720   arg2 = *argp2;
82721   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
82722   arg4 = (Dali::VerticalAlignment::Type)jarg4;
82723   {
82724     try {
82725       (arg1)->SetCellAlignment(arg2,arg3,arg4);
82726     } catch (std::out_of_range& e) {
82727       {
82728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82729       };
82730     } catch (std::exception& e) {
82731       {
82732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82733       };
82734     } catch (Dali::DaliException e) {
82735       {
82736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82737       };
82738     } catch (...) {
82739       {
82740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82741       };
82742     }
82743   }
82744
82745 }
82746
82747
82748 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
82749   unsigned int jresult ;
82750   unsigned int result;
82751
82752   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
82753   jresult = result;
82754   return jresult;
82755 }
82756
82757
82758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
82759   int jresult ;
82760   int result;
82761
82762   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
82763   jresult = (int)result;
82764   return jresult;
82765 }
82766
82767
82768 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
82769   int jresult ;
82770   int result;
82771
82772   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
82773   jresult = (int)result;
82774   return jresult;
82775 }
82776
82777
82778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
82779   int jresult ;
82780   int result;
82781
82782   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
82783   jresult = (int)result;
82784   return jresult;
82785 }
82786
82787
82788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
82789   int jresult ;
82790   int result;
82791
82792   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
82793   jresult = (int)result;
82794   return jresult;
82795 }
82796
82797
82798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
82799   int jresult ;
82800   int result;
82801
82802   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
82803   jresult = (int)result;
82804   return jresult;
82805 }
82806
82807
82808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
82809   int jresult ;
82810   int result;
82811
82812   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
82813   jresult = (int)result;
82814   return jresult;
82815 }
82816
82817
82818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
82819   int jresult ;
82820   int result;
82821
82822   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
82823   jresult = (int)result;
82824   return jresult;
82825 }
82826
82827
82828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
82829   int jresult ;
82830   int result;
82831
82832   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
82833   jresult = (int)result;
82834   return jresult;
82835 }
82836
82837
82838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
82839   int jresult ;
82840   int result;
82841
82842   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
82843   jresult = (int)result;
82844   return jresult;
82845 }
82846
82847
82848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
82849   int jresult ;
82850   int result;
82851
82852   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
82853   jresult = (int)result;
82854   return jresult;
82855 }
82856
82857
82858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
82859   int jresult ;
82860   int result;
82861
82862   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
82863   jresult = (int)result;
82864   return jresult;
82865 }
82866
82867
82868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
82869   int jresult ;
82870   int result;
82871
82872   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
82873   jresult = (int)result;
82874   return jresult;
82875 }
82876
82877
82878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
82879   int jresult ;
82880   int result;
82881
82882   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
82883   jresult = (int)result;
82884   return jresult;
82885 }
82886
82887
82888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
82889   int jresult ;
82890   int result;
82891
82892   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
82893   jresult = (int)result;
82894   return jresult;
82895 }
82896
82897
82898 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
82899   int jresult ;
82900   int result;
82901
82902   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
82903   jresult = (int)result;
82904   return jresult;
82905 }
82906
82907
82908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
82909   int jresult ;
82910   int result;
82911
82912   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
82913   jresult = (int)result;
82914   return jresult;
82915 }
82916
82917
82918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
82919   int jresult ;
82920   int result;
82921
82922   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
82923   jresult = (int)result;
82924   return jresult;
82925 }
82926
82927
82928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
82929   int jresult ;
82930   int result;
82931
82932   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
82933   jresult = (int)result;
82934   return jresult;
82935 }
82936
82937
82938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
82939   int jresult ;
82940   int result;
82941
82942   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
82943   jresult = (int)result;
82944   return jresult;
82945 }
82946
82947
82948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
82949   void * jresult ;
82950   Dali::Toolkit::TextLabel::Property *result = 0 ;
82951
82952   {
82953     try {
82954       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
82955     } catch (std::out_of_range& e) {
82956       {
82957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82958       };
82959     } catch (std::exception& e) {
82960       {
82961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82962       };
82963     } catch (Dali::DaliException e) {
82964       {
82965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82966       };
82967     } catch (...) {
82968       {
82969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82970       };
82971     }
82972   }
82973
82974   jresult = (void *)result;
82975   return jresult;
82976 }
82977
82978
82979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
82980   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
82981
82982   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
82983   {
82984     try {
82985       delete arg1;
82986     } catch (std::out_of_range& e) {
82987       {
82988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82989       };
82990     } catch (std::exception& e) {
82991       {
82992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82993       };
82994     } catch (Dali::DaliException e) {
82995       {
82996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82997       };
82998     } catch (...) {
82999       {
83000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83001       };
83002     }
83003   }
83004
83005 }
83006
83007
83008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
83009   void * jresult ;
83010   Dali::Toolkit::TextLabel result;
83011
83012   {
83013     try {
83014       result = Dali::Toolkit::TextLabel::New();
83015     } catch (std::out_of_range& e) {
83016       {
83017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83018       };
83019     } catch (std::exception& e) {
83020       {
83021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83022       };
83023     } catch (Dali::DaliException e) {
83024       {
83025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83026       };
83027     } catch (...) {
83028       {
83029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83030       };
83031     }
83032   }
83033
83034   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
83035   return jresult;
83036 }
83037
83038
83039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
83040   void * jresult ;
83041   std::string *arg1 = 0 ;
83042   Dali::Toolkit::TextLabel result;
83043
83044   if (!jarg1) {
83045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
83046     return 0;
83047   }
83048   std::string arg1_str(jarg1);
83049   arg1 = &arg1_str;
83050   {
83051     try {
83052       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
83053     } catch (std::out_of_range& e) {
83054       {
83055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83056       };
83057     } catch (std::exception& e) {
83058       {
83059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83060       };
83061     } catch (Dali::DaliException e) {
83062       {
83063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83064       };
83065     } catch (...) {
83066       {
83067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83068       };
83069     }
83070   }
83071
83072   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
83073
83074   //argout typemap for const std::string&
83075
83076   return jresult;
83077 }
83078
83079
83080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
83081   void * jresult ;
83082   Dali::Toolkit::TextLabel *result = 0 ;
83083
83084   {
83085     try {
83086       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
83087     } catch (std::out_of_range& e) {
83088       {
83089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83090       };
83091     } catch (std::exception& e) {
83092       {
83093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83094       };
83095     } catch (Dali::DaliException e) {
83096       {
83097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83098       };
83099     } catch (...) {
83100       {
83101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83102       };
83103     }
83104   }
83105
83106   jresult = (void *)result;
83107   return jresult;
83108 }
83109
83110
83111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
83112   void * jresult ;
83113   Dali::Toolkit::TextLabel *arg1 = 0 ;
83114   Dali::Toolkit::TextLabel *result = 0 ;
83115
83116   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
83117   if (!arg1) {
83118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
83119     return 0;
83120   }
83121   {
83122     try {
83123       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
83124     } catch (std::out_of_range& e) {
83125       {
83126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83127       };
83128     } catch (std::exception& e) {
83129       {
83130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83131       };
83132     } catch (Dali::DaliException e) {
83133       {
83134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83135       };
83136     } catch (...) {
83137       {
83138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83139       };
83140     }
83141   }
83142
83143   jresult = (void *)result;
83144   return jresult;
83145 }
83146
83147
83148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
83149   void * jresult ;
83150   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
83151   Dali::Toolkit::TextLabel *arg2 = 0 ;
83152   Dali::Toolkit::TextLabel *result = 0 ;
83153
83154   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
83155   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
83156   if (!arg2) {
83157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
83158     return 0;
83159   }
83160   {
83161     try {
83162       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
83163     } catch (std::out_of_range& e) {
83164       {
83165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83166       };
83167     } catch (std::exception& e) {
83168       {
83169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83170       };
83171     } catch (Dali::DaliException e) {
83172       {
83173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83174       };
83175     } catch (...) {
83176       {
83177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83178       };
83179     }
83180   }
83181
83182   jresult = (void *)result;
83183   return jresult;
83184 }
83185
83186
83187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
83188   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
83189
83190   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
83191   {
83192     try {
83193       delete arg1;
83194     } catch (std::out_of_range& e) {
83195       {
83196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83197       };
83198     } catch (std::exception& e) {
83199       {
83200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83201       };
83202     } catch (Dali::DaliException e) {
83203       {
83204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83205       };
83206     } catch (...) {
83207       {
83208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83209       };
83210     }
83211   }
83212
83213 }
83214
83215
83216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
83217   void * jresult ;
83218   Dali::BaseHandle arg1 ;
83219   Dali::BaseHandle *argp1 ;
83220   Dali::Toolkit::TextLabel result;
83221
83222   argp1 = (Dali::BaseHandle *)jarg1;
83223   if (!argp1) {
83224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83225     return 0;
83226   }
83227   arg1 = *argp1;
83228   {
83229     try {
83230       result = Dali::Toolkit::TextLabel::DownCast(arg1);
83231     } catch (std::out_of_range& e) {
83232       {
83233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83234       };
83235     } catch (std::exception& e) {
83236       {
83237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83238       };
83239     } catch (Dali::DaliException e) {
83240       {
83241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83242       };
83243     } catch (...) {
83244       {
83245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83246       };
83247     }
83248   }
83249
83250   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
83251   return jresult;
83252 }
83253
83254
83255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
83256   void * jresult ;
83257   Dali::Toolkit::AccessibilityManager *result = 0 ;
83258
83259   {
83260     try {
83261       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
83262     } catch (std::out_of_range& e) {
83263       {
83264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83265       };
83266     } catch (std::exception& e) {
83267       {
83268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83269       };
83270     } catch (Dali::DaliException e) {
83271       {
83272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83273       };
83274     } catch (...) {
83275       {
83276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83277       };
83278     }
83279   }
83280
83281   jresult = (void *)result;
83282   return jresult;
83283 }
83284
83285
83286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
83287   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83288
83289   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83290   {
83291     try {
83292       delete arg1;
83293     } catch (std::out_of_range& e) {
83294       {
83295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83296       };
83297     } catch (std::exception& e) {
83298       {
83299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83300       };
83301     } catch (Dali::DaliException e) {
83302       {
83303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83304       };
83305     } catch (...) {
83306       {
83307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83308       };
83309     }
83310   }
83311
83312 }
83313
83314
83315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
83316   void * jresult ;
83317   Dali::Toolkit::AccessibilityManager result;
83318
83319   {
83320     try {
83321       result = Dali::Toolkit::AccessibilityManager::Get();
83322     } catch (std::out_of_range& e) {
83323       {
83324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83325       };
83326     } catch (std::exception& e) {
83327       {
83328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83329       };
83330     } catch (Dali::DaliException e) {
83331       {
83332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83333       };
83334     } catch (...) {
83335       {
83336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83337       };
83338     }
83339   }
83340
83341   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
83342   return jresult;
83343 }
83344
83345
83346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
83347   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83348   Dali::Actor arg2 ;
83349   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
83350   std::string *arg4 = 0 ;
83351   Dali::Actor *argp2 ;
83352
83353   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83354   argp2 = (Dali::Actor *)jarg2;
83355   if (!argp2) {
83356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83357     return ;
83358   }
83359   arg2 = *argp2;
83360   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
83361   if (!jarg4) {
83362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
83363     return ;
83364   }
83365   std::string arg4_str(jarg4);
83366   arg4 = &arg4_str;
83367   {
83368     try {
83369       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
83370     } catch (std::out_of_range& e) {
83371       {
83372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83373       };
83374     } catch (std::exception& e) {
83375       {
83376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83377       };
83378     } catch (Dali::DaliException e) {
83379       {
83380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83381       };
83382     } catch (...) {
83383       {
83384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83385       };
83386     }
83387   }
83388
83389
83390   //argout typemap for const std::string&
83391
83392 }
83393
83394
83395 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
83396   char * jresult ;
83397   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83398   Dali::Actor arg2 ;
83399   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
83400   Dali::Actor *argp2 ;
83401   std::string result;
83402
83403   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83404   argp2 = (Dali::Actor *)jarg2;
83405   if (!argp2) {
83406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83407     return 0;
83408   }
83409   arg2 = *argp2;
83410   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
83411   {
83412     try {
83413       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
83414     } catch (std::out_of_range& e) {
83415       {
83416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83417       };
83418     } catch (std::exception& e) {
83419       {
83420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83421       };
83422     } catch (Dali::DaliException e) {
83423       {
83424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83425       };
83426     } catch (...) {
83427       {
83428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83429       };
83430     }
83431   }
83432
83433   jresult = SWIG_csharp_string_callback((&result)->c_str());
83434   return jresult;
83435 }
83436
83437
83438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
83439   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83440   Dali::Actor arg2 ;
83441   unsigned int arg3 ;
83442   Dali::Actor *argp2 ;
83443
83444   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83445   argp2 = (Dali::Actor *)jarg2;
83446   if (!argp2) {
83447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83448     return ;
83449   }
83450   arg2 = *argp2;
83451   arg3 = (unsigned int)jarg3;
83452   {
83453     try {
83454       (arg1)->SetFocusOrder(arg2,arg3);
83455     } catch (std::out_of_range& e) {
83456       {
83457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83458       };
83459     } catch (std::exception& e) {
83460       {
83461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83462       };
83463     } catch (Dali::DaliException e) {
83464       {
83465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83466       };
83467     } catch (...) {
83468       {
83469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83470       };
83471     }
83472   }
83473
83474 }
83475
83476
83477 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
83478   unsigned int jresult ;
83479   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83480   Dali::Actor arg2 ;
83481   Dali::Actor *argp2 ;
83482   unsigned int result;
83483
83484   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83485   argp2 = (Dali::Actor *)jarg2;
83486   if (!argp2) {
83487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83488     return 0;
83489   }
83490   arg2 = *argp2;
83491   {
83492     try {
83493       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
83494     } catch (std::out_of_range& e) {
83495       {
83496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83497       };
83498     } catch (std::exception& e) {
83499       {
83500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83501       };
83502     } catch (Dali::DaliException e) {
83503       {
83504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83505       };
83506     } catch (...) {
83507       {
83508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83509       };
83510     }
83511   }
83512
83513   jresult = result;
83514   return jresult;
83515 }
83516
83517
83518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
83519   unsigned int jresult ;
83520   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83521   unsigned int result;
83522
83523   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83524   {
83525     try {
83526       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
83527     } catch (std::out_of_range& e) {
83528       {
83529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83530       };
83531     } catch (std::exception& e) {
83532       {
83533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83534       };
83535     } catch (Dali::DaliException e) {
83536       {
83537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83538       };
83539     } catch (...) {
83540       {
83541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83542       };
83543     }
83544   }
83545
83546   jresult = result;
83547   return jresult;
83548 }
83549
83550
83551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
83552   void * jresult ;
83553   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83554   unsigned int arg2 ;
83555   Dali::Actor result;
83556
83557   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83558   arg2 = (unsigned int)jarg2;
83559   {
83560     try {
83561       result = (arg1)->GetActorByFocusOrder(arg2);
83562     } catch (std::out_of_range& e) {
83563       {
83564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83565       };
83566     } catch (std::exception& e) {
83567       {
83568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83569       };
83570     } catch (Dali::DaliException e) {
83571       {
83572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83573       };
83574     } catch (...) {
83575       {
83576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83577       };
83578     }
83579   }
83580
83581   jresult = new Dali::Actor((const Dali::Actor &)result);
83582   return jresult;
83583 }
83584
83585
83586 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
83587   unsigned int jresult ;
83588   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83589   Dali::Actor arg2 ;
83590   Dali::Actor *argp2 ;
83591   bool result;
83592
83593   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83594   argp2 = (Dali::Actor *)jarg2;
83595   if (!argp2) {
83596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83597     return 0;
83598   }
83599   arg2 = *argp2;
83600   {
83601     try {
83602       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
83603     } catch (std::out_of_range& e) {
83604       {
83605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83606       };
83607     } catch (std::exception& e) {
83608       {
83609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83610       };
83611     } catch (Dali::DaliException e) {
83612       {
83613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83614       };
83615     } catch (...) {
83616       {
83617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83618       };
83619     }
83620   }
83621
83622   jresult = result;
83623   return jresult;
83624 }
83625
83626
83627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
83628   void * jresult ;
83629   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83630   Dali::Actor result;
83631
83632   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83633   {
83634     try {
83635       result = (arg1)->GetCurrentFocusActor();
83636     } catch (std::out_of_range& e) {
83637       {
83638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83639       };
83640     } catch (std::exception& e) {
83641       {
83642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83643       };
83644     } catch (Dali::DaliException e) {
83645       {
83646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83647       };
83648     } catch (...) {
83649       {
83650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83651       };
83652     }
83653   }
83654
83655   jresult = new Dali::Actor((const Dali::Actor &)result);
83656   return jresult;
83657 }
83658
83659
83660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
83661   void * jresult ;
83662   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83663   Dali::Actor result;
83664
83665   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83666   {
83667     try {
83668       result = (arg1)->GetCurrentFocusGroup();
83669     } catch (std::out_of_range& e) {
83670       {
83671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83672       };
83673     } catch (std::exception& e) {
83674       {
83675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83676       };
83677     } catch (Dali::DaliException e) {
83678       {
83679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83680       };
83681     } catch (...) {
83682       {
83683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83684       };
83685     }
83686   }
83687
83688   jresult = new Dali::Actor((const Dali::Actor &)result);
83689   return jresult;
83690 }
83691
83692
83693 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
83694   unsigned int jresult ;
83695   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83696   unsigned int result;
83697
83698   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83699   {
83700     try {
83701       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
83702     } catch (std::out_of_range& e) {
83703       {
83704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83705       };
83706     } catch (std::exception& e) {
83707       {
83708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83709       };
83710     } catch (Dali::DaliException e) {
83711       {
83712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83713       };
83714     } catch (...) {
83715       {
83716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83717       };
83718     }
83719   }
83720
83721   jresult = result;
83722   return jresult;
83723 }
83724
83725
83726 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
83727   unsigned int jresult ;
83728   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83729   bool result;
83730
83731   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83732   {
83733     try {
83734       result = (bool)(arg1)->MoveFocusForward();
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 = result;
83755   return jresult;
83756 }
83757
83758
83759 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
83760   unsigned int jresult ;
83761   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83762   bool result;
83763
83764   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83765   {
83766     try {
83767       result = (bool)(arg1)->MoveFocusBackward();
83768     } catch (std::out_of_range& e) {
83769       {
83770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83771       };
83772     } catch (std::exception& e) {
83773       {
83774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83775       };
83776     } catch (Dali::DaliException e) {
83777       {
83778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83779       };
83780     } catch (...) {
83781       {
83782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83783       };
83784     }
83785   }
83786
83787   jresult = result;
83788   return jresult;
83789 }
83790
83791
83792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
83793   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83794
83795   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83796   {
83797     try {
83798       (arg1)->ClearFocus();
83799     } catch (std::out_of_range& e) {
83800       {
83801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83802       };
83803     } catch (std::exception& e) {
83804       {
83805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83806       };
83807     } catch (Dali::DaliException e) {
83808       {
83809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83810       };
83811     } catch (...) {
83812       {
83813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83814       };
83815     }
83816   }
83817
83818 }
83819
83820
83821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
83822   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83823
83824   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83825   {
83826     try {
83827       (arg1)->Reset();
83828     } catch (std::out_of_range& e) {
83829       {
83830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83831       };
83832     } catch (std::exception& e) {
83833       {
83834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83835       };
83836     } catch (Dali::DaliException e) {
83837       {
83838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83839       };
83840     } catch (...) {
83841       {
83842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83843       };
83844     }
83845   }
83846
83847 }
83848
83849
83850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
83851   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83852   Dali::Actor arg2 ;
83853   bool arg3 ;
83854   Dali::Actor *argp2 ;
83855
83856   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83857   argp2 = (Dali::Actor *)jarg2;
83858   if (!argp2) {
83859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83860     return ;
83861   }
83862   arg2 = *argp2;
83863   arg3 = jarg3 ? true : false;
83864   {
83865     try {
83866       (arg1)->SetFocusGroup(arg2,arg3);
83867     } catch (std::out_of_range& e) {
83868       {
83869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83870       };
83871     } catch (std::exception& e) {
83872       {
83873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83874       };
83875     } catch (Dali::DaliException e) {
83876       {
83877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83878       };
83879     } catch (...) {
83880       {
83881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83882       };
83883     }
83884   }
83885
83886 }
83887
83888
83889 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
83890   unsigned int jresult ;
83891   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83892   Dali::Actor arg2 ;
83893   Dali::Actor *argp2 ;
83894   bool result;
83895
83896   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83897   argp2 = (Dali::Actor *)jarg2;
83898   if (!argp2) {
83899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83900     return 0;
83901   }
83902   arg2 = *argp2;
83903   {
83904     try {
83905       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
83906     } catch (std::out_of_range& e) {
83907       {
83908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83909       };
83910     } catch (std::exception& e) {
83911       {
83912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83913       };
83914     } catch (Dali::DaliException e) {
83915       {
83916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83917       };
83918     } catch (...) {
83919       {
83920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83921       };
83922     }
83923   }
83924
83925   jresult = result;
83926   return jresult;
83927 }
83928
83929
83930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
83931   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83932   bool arg2 ;
83933
83934   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83935   arg2 = jarg2 ? true : false;
83936   {
83937     try {
83938       (arg1)->SetGroupMode(arg2);
83939     } catch (std::out_of_range& e) {
83940       {
83941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83942       };
83943     } catch (std::exception& e) {
83944       {
83945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83946       };
83947     } catch (Dali::DaliException e) {
83948       {
83949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83950       };
83951     } catch (...) {
83952       {
83953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83954       };
83955     }
83956   }
83957
83958 }
83959
83960
83961 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
83962   unsigned int jresult ;
83963   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83964   bool result;
83965
83966   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83967   {
83968     try {
83969       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
83970     } catch (std::out_of_range& e) {
83971       {
83972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83973       };
83974     } catch (std::exception& e) {
83975       {
83976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83977       };
83978     } catch (Dali::DaliException e) {
83979       {
83980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83981       };
83982     } catch (...) {
83983       {
83984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83985       };
83986     }
83987   }
83988
83989   jresult = result;
83990   return jresult;
83991 }
83992
83993
83994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
83995   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83996   bool arg2 ;
83997
83998   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83999   arg2 = jarg2 ? true : false;
84000   {
84001     try {
84002       (arg1)->SetWrapMode(arg2);
84003     } catch (std::out_of_range& e) {
84004       {
84005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84006       };
84007     } catch (std::exception& e) {
84008       {
84009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84010       };
84011     } catch (Dali::DaliException e) {
84012       {
84013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84014       };
84015     } catch (...) {
84016       {
84017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84018       };
84019     }
84020   }
84021
84022 }
84023
84024
84025 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
84026   unsigned int jresult ;
84027   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84028   bool result;
84029
84030   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84031   {
84032     try {
84033       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
84034     } catch (std::out_of_range& e) {
84035       {
84036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84037       };
84038     } catch (std::exception& e) {
84039       {
84040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84041       };
84042     } catch (Dali::DaliException e) {
84043       {
84044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84045       };
84046     } catch (...) {
84047       {
84048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84049       };
84050     }
84051   }
84052
84053   jresult = result;
84054   return jresult;
84055 }
84056
84057
84058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
84059   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84060   Dali::Actor arg2 ;
84061   Dali::Actor *argp2 ;
84062
84063   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84064   argp2 = (Dali::Actor *)jarg2;
84065   if (!argp2) {
84066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84067     return ;
84068   }
84069   arg2 = *argp2;
84070   {
84071     try {
84072       (arg1)->SetFocusIndicatorActor(arg2);
84073     } catch (std::out_of_range& e) {
84074       {
84075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84076       };
84077     } catch (std::exception& e) {
84078       {
84079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84080       };
84081     } catch (Dali::DaliException e) {
84082       {
84083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84084       };
84085     } catch (...) {
84086       {
84087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84088       };
84089     }
84090   }
84091
84092 }
84093
84094
84095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
84096   void * jresult ;
84097   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84098   Dali::Actor result;
84099
84100   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84101   {
84102     try {
84103       result = (arg1)->GetFocusIndicatorActor();
84104     } catch (std::out_of_range& e) {
84105       {
84106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84107       };
84108     } catch (std::exception& e) {
84109       {
84110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84111       };
84112     } catch (Dali::DaliException e) {
84113       {
84114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84115       };
84116     } catch (...) {
84117       {
84118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84119       };
84120     }
84121   }
84122
84123   jresult = new Dali::Actor((const Dali::Actor &)result);
84124   return jresult;
84125 }
84126
84127
84128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
84129   void * jresult ;
84130   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84131   Dali::Actor arg2 ;
84132   Dali::Actor *argp2 ;
84133   Dali::Actor result;
84134
84135   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84136   argp2 = (Dali::Actor *)jarg2;
84137   if (!argp2) {
84138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84139     return 0;
84140   }
84141   arg2 = *argp2;
84142   {
84143     try {
84144       result = (arg1)->GetFocusGroup(arg2);
84145     } catch (std::out_of_range& e) {
84146       {
84147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84148       };
84149     } catch (std::exception& e) {
84150       {
84151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84152       };
84153     } catch (Dali::DaliException e) {
84154       {
84155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84156       };
84157     } catch (...) {
84158       {
84159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84160       };
84161     }
84162   }
84163
84164   jresult = new Dali::Actor((const Dali::Actor &)result);
84165   return jresult;
84166 }
84167
84168
84169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
84170   void * jresult ;
84171   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84172   Dali::Vector2 result;
84173
84174   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84175   {
84176     try {
84177       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
84178     } catch (std::out_of_range& e) {
84179       {
84180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84181       };
84182     } catch (std::exception& e) {
84183       {
84184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84185       };
84186     } catch (Dali::DaliException e) {
84187       {
84188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84189       };
84190     } catch (...) {
84191       {
84192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84193       };
84194     }
84195   }
84196
84197   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
84198   return jresult;
84199 }
84200
84201
84202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
84203   void * jresult ;
84204   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84205   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
84206
84207   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84208   {
84209     try {
84210       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
84211     } catch (std::out_of_range& e) {
84212       {
84213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84214       };
84215     } catch (std::exception& e) {
84216       {
84217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84218       };
84219     } catch (Dali::DaliException e) {
84220       {
84221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84222       };
84223     } catch (...) {
84224       {
84225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84226       };
84227     }
84228   }
84229
84230   jresult = (void *)result;
84231   return jresult;
84232 }
84233
84234
84235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
84236   void * jresult ;
84237   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84238   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
84239
84240   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84241   {
84242     try {
84243       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
84244     } catch (std::out_of_range& e) {
84245       {
84246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84247       };
84248     } catch (std::exception& e) {
84249       {
84250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84251       };
84252     } catch (Dali::DaliException e) {
84253       {
84254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84255       };
84256     } catch (...) {
84257       {
84258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84259       };
84260     }
84261   }
84262
84263   jresult = (void *)result;
84264   return jresult;
84265 }
84266
84267
84268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
84269   void * jresult ;
84270   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84271   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
84272
84273   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84274   {
84275     try {
84276       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
84277     } catch (std::out_of_range& e) {
84278       {
84279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84280       };
84281     } catch (std::exception& e) {
84282       {
84283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84284       };
84285     } catch (Dali::DaliException e) {
84286       {
84287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84288       };
84289     } catch (...) {
84290       {
84291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84292       };
84293     }
84294   }
84295
84296   jresult = (void *)result;
84297   return jresult;
84298 }
84299
84300
84301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
84302   void * jresult ;
84303   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84304   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84305
84306   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84307   {
84308     try {
84309       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
84310     } catch (std::out_of_range& e) {
84311       {
84312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84313       };
84314     } catch (std::exception& e) {
84315       {
84316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84317       };
84318     } catch (Dali::DaliException e) {
84319       {
84320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84321       };
84322     } catch (...) {
84323       {
84324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84325       };
84326     }
84327   }
84328
84329   jresult = (void *)result;
84330   return jresult;
84331 }
84332
84333
84334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
84335   void * jresult ;
84336   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84337   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84338
84339   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84340   {
84341     try {
84342       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
84343     } catch (std::out_of_range& e) {
84344       {
84345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84346       };
84347     } catch (std::exception& e) {
84348       {
84349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84350       };
84351     } catch (Dali::DaliException e) {
84352       {
84353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84354       };
84355     } catch (...) {
84356       {
84357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84358       };
84359     }
84360   }
84361
84362   jresult = (void *)result;
84363   return jresult;
84364 }
84365
84366
84367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
84368   void * jresult ;
84369   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84370   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84371
84372   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84373   {
84374     try {
84375       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
84376     } catch (std::out_of_range& e) {
84377       {
84378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84379       };
84380     } catch (std::exception& e) {
84381       {
84382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84383       };
84384     } catch (Dali::DaliException e) {
84385       {
84386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84387       };
84388     } catch (...) {
84389       {
84390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84391       };
84392     }
84393   }
84394
84395   jresult = (void *)result;
84396   return jresult;
84397 }
84398
84399
84400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
84401   void * jresult ;
84402   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84403   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84404
84405   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84406   {
84407     try {
84408       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
84409     } catch (std::out_of_range& e) {
84410       {
84411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84412       };
84413     } catch (std::exception& e) {
84414       {
84415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84416       };
84417     } catch (Dali::DaliException e) {
84418       {
84419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84420       };
84421     } catch (...) {
84422       {
84423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84424       };
84425     }
84426   }
84427
84428   jresult = (void *)result;
84429   return jresult;
84430 }
84431
84432
84433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
84434   void * jresult ;
84435   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84436   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84437
84438   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84439   {
84440     try {
84441       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
84442     } catch (std::out_of_range& e) {
84443       {
84444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84445       };
84446     } catch (std::exception& e) {
84447       {
84448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84449       };
84450     } catch (Dali::DaliException e) {
84451       {
84452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84453       };
84454     } catch (...) {
84455       {
84456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84457       };
84458     }
84459   }
84460
84461   jresult = (void *)result;
84462   return jresult;
84463 }
84464
84465
84466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
84467   void * jresult ;
84468   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84469   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84470
84471   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84472   {
84473     try {
84474       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
84475     } catch (std::out_of_range& e) {
84476       {
84477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84478       };
84479     } catch (std::exception& e) {
84480       {
84481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84482       };
84483     } catch (Dali::DaliException e) {
84484       {
84485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84486       };
84487     } catch (...) {
84488       {
84489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84490       };
84491     }
84492   }
84493
84494   jresult = (void *)result;
84495   return jresult;
84496 }
84497
84498
84499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
84500   void * jresult ;
84501   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84502   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84503
84504   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84505   {
84506     try {
84507       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
84508     } catch (std::out_of_range& e) {
84509       {
84510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84511       };
84512     } catch (std::exception& e) {
84513       {
84514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84515       };
84516     } catch (Dali::DaliException e) {
84517       {
84518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84519       };
84520     } catch (...) {
84521       {
84522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84523       };
84524     }
84525   }
84526
84527   jresult = (void *)result;
84528   return jresult;
84529 }
84530
84531
84532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
84533   void * jresult ;
84534   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84535   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84536
84537   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84538   {
84539     try {
84540       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
84541     } catch (std::out_of_range& e) {
84542       {
84543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84544       };
84545     } catch (std::exception& e) {
84546       {
84547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84548       };
84549     } catch (Dali::DaliException e) {
84550       {
84551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84552       };
84553     } catch (...) {
84554       {
84555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84556       };
84557     }
84558   }
84559
84560   jresult = (void *)result;
84561   return jresult;
84562 }
84563
84564
84565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
84566   void * jresult ;
84567   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84568   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84569
84570   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84571   {
84572     try {
84573       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
84574     } catch (std::out_of_range& e) {
84575       {
84576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84577       };
84578     } catch (std::exception& e) {
84579       {
84580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84581       };
84582     } catch (Dali::DaliException e) {
84583       {
84584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84585       };
84586     } catch (...) {
84587       {
84588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84589       };
84590     }
84591   }
84592
84593   jresult = (void *)result;
84594   return jresult;
84595 }
84596
84597
84598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
84599   void * jresult ;
84600   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84601   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84602
84603   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84604   {
84605     try {
84606       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
84607     } catch (std::out_of_range& e) {
84608       {
84609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84610       };
84611     } catch (std::exception& e) {
84612       {
84613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84614       };
84615     } catch (Dali::DaliException e) {
84616       {
84617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84618       };
84619     } catch (...) {
84620       {
84621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84622       };
84623     }
84624   }
84625
84626   jresult = (void *)result;
84627   return jresult;
84628 }
84629
84630
84631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
84632   void * jresult ;
84633   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84634   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84635
84636   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84637   {
84638     try {
84639       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
84640     } catch (std::out_of_range& e) {
84641       {
84642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84643       };
84644     } catch (std::exception& e) {
84645       {
84646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84647       };
84648     } catch (Dali::DaliException e) {
84649       {
84650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84651       };
84652     } catch (...) {
84653       {
84654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84655       };
84656     }
84657   }
84658
84659   jresult = (void *)result;
84660   return jresult;
84661 }
84662
84663
84664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
84665   void * jresult ;
84666   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84667   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84668
84669   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84670   {
84671     try {
84672       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
84673     } catch (std::out_of_range& e) {
84674       {
84675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84676       };
84677     } catch (std::exception& e) {
84678       {
84679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84680       };
84681     } catch (Dali::DaliException e) {
84682       {
84683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84684       };
84685     } catch (...) {
84686       {
84687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84688       };
84689     }
84690   }
84691
84692   jresult = (void *)result;
84693   return jresult;
84694 }
84695
84696
84697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
84698   void * jresult ;
84699   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84700   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84701
84702   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84703   {
84704     try {
84705       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
84706     } catch (std::out_of_range& e) {
84707       {
84708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84709       };
84710     } catch (std::exception& e) {
84711       {
84712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84713       };
84714     } catch (Dali::DaliException e) {
84715       {
84716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84717       };
84718     } catch (...) {
84719       {
84720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84721       };
84722     }
84723   }
84724
84725   jresult = (void *)result;
84726   return jresult;
84727 }
84728
84729
84730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
84731   void * jresult ;
84732   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84733   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84734
84735   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84736   {
84737     try {
84738       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
84739     } catch (std::out_of_range& e) {
84740       {
84741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84742       };
84743     } catch (std::exception& e) {
84744       {
84745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84746       };
84747     } catch (Dali::DaliException e) {
84748       {
84749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84750       };
84751     } catch (...) {
84752       {
84753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84754       };
84755     }
84756   }
84757
84758   jresult = (void *)result;
84759   return jresult;
84760 }
84761
84762
84763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
84764   void * jresult ;
84765   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84766   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84767
84768   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84769   {
84770     try {
84771       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
84772     } catch (std::out_of_range& e) {
84773       {
84774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84775       };
84776     } catch (std::exception& e) {
84777       {
84778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84779       };
84780     } catch (Dali::DaliException e) {
84781       {
84782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84783       };
84784     } catch (...) {
84785       {
84786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84787       };
84788     }
84789   }
84790
84791   jresult = (void *)result;
84792   return jresult;
84793 }
84794
84795
84796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
84797   void * jresult ;
84798   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84799   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84800
84801   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84802   {
84803     try {
84804       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
84805     } catch (std::out_of_range& e) {
84806       {
84807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84808       };
84809     } catch (std::exception& e) {
84810       {
84811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84812       };
84813     } catch (Dali::DaliException e) {
84814       {
84815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84816       };
84817     } catch (...) {
84818       {
84819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84820       };
84821     }
84822   }
84823
84824   jresult = (void *)result;
84825   return jresult;
84826 }
84827
84828
84829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
84830   void * jresult ;
84831   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84832   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84833
84834   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84835   {
84836     try {
84837       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
84838     } catch (std::out_of_range& e) {
84839       {
84840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84841       };
84842     } catch (std::exception& e) {
84843       {
84844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84845       };
84846     } catch (Dali::DaliException e) {
84847       {
84848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84849       };
84850     } catch (...) {
84851       {
84852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84853       };
84854     }
84855   }
84856
84857   jresult = (void *)result;
84858   return jresult;
84859 }
84860
84861
84862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
84863   void * jresult ;
84864   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84865   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84866
84867   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84868   {
84869     try {
84870       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
84871     } catch (std::out_of_range& e) {
84872       {
84873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84874       };
84875     } catch (std::exception& e) {
84876       {
84877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84878       };
84879     } catch (Dali::DaliException e) {
84880       {
84881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84882       };
84883     } catch (...) {
84884       {
84885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84886       };
84887     }
84888   }
84889
84890   jresult = (void *)result;
84891   return jresult;
84892 }
84893
84894
84895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
84896   void * jresult ;
84897   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84898   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84899
84900   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84901   {
84902     try {
84903       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
84904     } catch (std::out_of_range& e) {
84905       {
84906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84907       };
84908     } catch (std::exception& e) {
84909       {
84910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84911       };
84912     } catch (Dali::DaliException e) {
84913       {
84914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84915       };
84916     } catch (...) {
84917       {
84918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84919       };
84920     }
84921   }
84922
84923   jresult = (void *)result;
84924   return jresult;
84925 }
84926
84927
84928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
84929   void * jresult ;
84930   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84931   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84932
84933   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84934   {
84935     try {
84936       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
84937     } catch (std::out_of_range& e) {
84938       {
84939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84940       };
84941     } catch (std::exception& e) {
84942       {
84943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84944       };
84945     } catch (Dali::DaliException e) {
84946       {
84947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84948       };
84949     } catch (...) {
84950       {
84951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84952       };
84953     }
84954   }
84955
84956   jresult = (void *)result;
84957   return jresult;
84958 }
84959
84960
84961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
84962   void * jresult ;
84963   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84964   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84965
84966   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84967   {
84968     try {
84969       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
84970     } catch (std::out_of_range& e) {
84971       {
84972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84973       };
84974     } catch (std::exception& e) {
84975       {
84976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84977       };
84978     } catch (Dali::DaliException e) {
84979       {
84980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84981       };
84982     } catch (...) {
84983       {
84984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84985       };
84986     }
84987   }
84988
84989   jresult = (void *)result;
84990   return jresult;
84991 }
84992
84993
84994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
84995   void * jresult ;
84996   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84997   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84998
84999   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85000   {
85001     try {
85002       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
85003     } catch (std::out_of_range& e) {
85004       {
85005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85006       };
85007     } catch (std::exception& e) {
85008       {
85009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85010       };
85011     } catch (Dali::DaliException e) {
85012       {
85013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85014       };
85015     } catch (...) {
85016       {
85017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85018       };
85019     }
85020   }
85021
85022   jresult = (void *)result;
85023   return jresult;
85024 }
85025
85026
85027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
85028   void * jresult ;
85029   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85030   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85031
85032   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85033   {
85034     try {
85035       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
85036     } catch (std::out_of_range& e) {
85037       {
85038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85039       };
85040     } catch (std::exception& e) {
85041       {
85042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85043       };
85044     } catch (Dali::DaliException e) {
85045       {
85046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85047       };
85048     } catch (...) {
85049       {
85050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85051       };
85052     }
85053   }
85054
85055   jresult = (void *)result;
85056   return jresult;
85057 }
85058
85059
85060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
85061   void * jresult ;
85062   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85063   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85064
85065   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85066   {
85067     try {
85068       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
85069     } catch (std::out_of_range& e) {
85070       {
85071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85072       };
85073     } catch (std::exception& e) {
85074       {
85075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85076       };
85077     } catch (Dali::DaliException e) {
85078       {
85079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85080       };
85081     } catch (...) {
85082       {
85083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85084       };
85085     }
85086   }
85087
85088   jresult = (void *)result;
85089   return jresult;
85090 }
85091
85092
85093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
85094   void * jresult ;
85095   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85096   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85097
85098   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85099   {
85100     try {
85101       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
85102     } catch (std::out_of_range& e) {
85103       {
85104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85105       };
85106     } catch (std::exception& e) {
85107       {
85108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85109       };
85110     } catch (Dali::DaliException e) {
85111       {
85112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85113       };
85114     } catch (...) {
85115       {
85116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85117       };
85118     }
85119   }
85120
85121   jresult = (void *)result;
85122   return jresult;
85123 }
85124
85125
85126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
85127   void * jresult ;
85128   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85129   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85130
85131   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85132   {
85133     try {
85134       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
85135     } catch (std::out_of_range& e) {
85136       {
85137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85138       };
85139     } catch (std::exception& e) {
85140       {
85141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85142       };
85143     } catch (Dali::DaliException e) {
85144       {
85145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85146       };
85147     } catch (...) {
85148       {
85149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85150       };
85151     }
85152   }
85153
85154   jresult = (void *)result;
85155   return jresult;
85156 }
85157
85158
85159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
85160   void * jresult ;
85161   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85162   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
85163
85164   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85165   {
85166     try {
85167       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
85168     } catch (std::out_of_range& e) {
85169       {
85170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85171       };
85172     } catch (std::exception& e) {
85173       {
85174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85175       };
85176     } catch (Dali::DaliException e) {
85177       {
85178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85179       };
85180     } catch (...) {
85181       {
85182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85183       };
85184     }
85185   }
85186
85187   jresult = (void *)result;
85188   return jresult;
85189 }
85190
85191
85192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
85193   void * jresult ;
85194   Dali::Toolkit::StyleManager *result = 0 ;
85195
85196   {
85197     try {
85198       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
85199     } catch (std::out_of_range& e) {
85200       {
85201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85202       };
85203     } catch (std::exception& e) {
85204       {
85205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85206       };
85207     } catch (Dali::DaliException e) {
85208       {
85209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85210       };
85211     } catch (...) {
85212       {
85213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85214       };
85215     }
85216   }
85217
85218   jresult = (void *)result;
85219   return jresult;
85220 }
85221
85222
85223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
85224   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85225
85226   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85227   {
85228     try {
85229       delete arg1;
85230     } catch (std::out_of_range& e) {
85231       {
85232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85233       };
85234     } catch (std::exception& e) {
85235       {
85236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85237       };
85238     } catch (Dali::DaliException e) {
85239       {
85240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85241       };
85242     } catch (...) {
85243       {
85244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85245       };
85246     }
85247   }
85248
85249 }
85250
85251
85252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
85253   void * jresult ;
85254   Dali::Toolkit::StyleManager result;
85255
85256   {
85257     try {
85258       result = Dali::Toolkit::StyleManager::Get();
85259     } catch (std::out_of_range& e) {
85260       {
85261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85262       };
85263     } catch (std::exception& e) {
85264       {
85265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85266       };
85267     } catch (Dali::DaliException e) {
85268       {
85269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85270       };
85271     } catch (...) {
85272       {
85273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85274       };
85275     }
85276   }
85277
85278   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
85279   return jresult;
85280 }
85281
85282
85283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
85284   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85285   std::string *arg2 = 0 ;
85286
85287   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85288   if (!jarg2) {
85289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85290     return ;
85291   }
85292   std::string arg2_str(jarg2);
85293   arg2 = &arg2_str;
85294   {
85295     try {
85296       (arg1)->ApplyTheme((std::string const &)*arg2);
85297     } catch (std::out_of_range& e) {
85298       {
85299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85300       };
85301     } catch (std::exception& e) {
85302       {
85303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85304       };
85305     } catch (Dali::DaliException e) {
85306       {
85307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85308       };
85309     } catch (...) {
85310       {
85311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85312       };
85313     }
85314   }
85315
85316
85317   //argout typemap for const std::string&
85318
85319 }
85320
85321
85322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
85323   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85324
85325   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85326   {
85327     try {
85328       (arg1)->ApplyDefaultTheme();
85329     } catch (std::out_of_range& e) {
85330       {
85331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85332       };
85333     } catch (std::exception& e) {
85334       {
85335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85336       };
85337     } catch (Dali::DaliException e) {
85338       {
85339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85340       };
85341     } catch (...) {
85342       {
85343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85344       };
85345     }
85346   }
85347
85348 }
85349
85350
85351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
85352   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85353   std::string *arg2 = 0 ;
85354   Dali::Property::Value *arg3 = 0 ;
85355
85356   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85357   if (!jarg2) {
85358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85359     return ;
85360   }
85361   std::string arg2_str(jarg2);
85362   arg2 = &arg2_str;
85363   arg3 = (Dali::Property::Value *)jarg3;
85364   if (!arg3) {
85365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
85366     return ;
85367   }
85368   {
85369     try {
85370       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
85371     } catch (std::out_of_range& e) {
85372       {
85373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85374       };
85375     } catch (std::exception& e) {
85376       {
85377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85378       };
85379     } catch (Dali::DaliException e) {
85380       {
85381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85382       };
85383     } catch (...) {
85384       {
85385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85386       };
85387     }
85388   }
85389
85390
85391   //argout typemap for const std::string&
85392
85393 }
85394
85395
85396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
85397   unsigned int jresult ;
85398   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85399   std::string *arg2 = 0 ;
85400   Dali::Property::Value *arg3 = 0 ;
85401   bool result;
85402
85403   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85404   if (!jarg2) {
85405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85406     return 0;
85407   }
85408   std::string arg2_str(jarg2);
85409   arg2 = &arg2_str;
85410   arg3 = (Dali::Property::Value *)jarg3;
85411   if (!arg3) {
85412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
85413     return 0;
85414   }
85415   {
85416     try {
85417       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
85418     } catch (std::out_of_range& e) {
85419       {
85420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85421       };
85422     } catch (std::exception& e) {
85423       {
85424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85425       };
85426     } catch (Dali::DaliException e) {
85427       {
85428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85429       };
85430     } catch (...) {
85431       {
85432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85433       };
85434     }
85435   }
85436
85437   jresult = result;
85438
85439   //argout typemap for const std::string&
85440
85441   return jresult;
85442 }
85443
85444
85445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
85446   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85447   Dali::Toolkit::Control arg2 ;
85448   std::string *arg3 = 0 ;
85449   std::string *arg4 = 0 ;
85450   Dali::Toolkit::Control *argp2 ;
85451
85452   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85453   argp2 = (Dali::Toolkit::Control *)jarg2;
85454   if (!argp2) {
85455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
85456     return ;
85457   }
85458   arg2 = *argp2;
85459   if (!jarg3) {
85460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85461     return ;
85462   }
85463   std::string arg3_str(jarg3);
85464   arg3 = &arg3_str;
85465   if (!jarg4) {
85466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85467     return ;
85468   }
85469   std::string arg4_str(jarg4);
85470   arg4 = &arg4_str;
85471   {
85472     try {
85473       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
85474     } catch (std::out_of_range& e) {
85475       {
85476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85477       };
85478     } catch (std::exception& e) {
85479       {
85480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85481       };
85482     } catch (Dali::DaliException e) {
85483       {
85484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85485       };
85486     } catch (...) {
85487       {
85488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85489       };
85490     }
85491   }
85492
85493
85494   //argout typemap for const std::string&
85495
85496
85497   //argout typemap for const std::string&
85498
85499 }
85500
85501
85502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
85503   void * jresult ;
85504   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85505   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
85506
85507   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85508   {
85509     try {
85510       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
85511     } catch (std::out_of_range& e) {
85512       {
85513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85514       };
85515     } catch (std::exception& e) {
85516       {
85517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85518       };
85519     } catch (Dali::DaliException e) {
85520       {
85521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85522       };
85523     } catch (...) {
85524       {
85525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85526       };
85527     }
85528   }
85529
85530   jresult = (void *)result;
85531   return jresult;
85532 }
85533
85534
85535 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
85536   int jresult ;
85537   int result;
85538
85539   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
85540   jresult = (int)result;
85541   return jresult;
85542 }
85543
85544
85545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
85546   int jresult ;
85547   int result;
85548
85549   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
85550   jresult = (int)result;
85551   return jresult;
85552 }
85553
85554
85555 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
85556   int jresult ;
85557   int result;
85558
85559   result = (int)Dali::Toolkit::Slider::Property::VALUE;
85560   jresult = (int)result;
85561   return jresult;
85562 }
85563
85564
85565 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
85566   int jresult ;
85567   int result;
85568
85569   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
85570   jresult = (int)result;
85571   return jresult;
85572 }
85573
85574
85575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
85576   int jresult ;
85577   int result;
85578
85579   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
85580   jresult = (int)result;
85581   return jresult;
85582 }
85583
85584
85585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
85586   int jresult ;
85587   int result;
85588
85589   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
85590   jresult = (int)result;
85591   return jresult;
85592 }
85593
85594
85595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
85596   int jresult ;
85597   int result;
85598
85599   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
85600   jresult = (int)result;
85601   return jresult;
85602 }
85603
85604
85605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
85606   int jresult ;
85607   int result;
85608
85609   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
85610   jresult = (int)result;
85611   return jresult;
85612 }
85613
85614
85615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
85616   int jresult ;
85617   int result;
85618
85619   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
85620   jresult = (int)result;
85621   return jresult;
85622 }
85623
85624
85625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
85626   int jresult ;
85627   int result;
85628
85629   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
85630   jresult = (int)result;
85631   return jresult;
85632 }
85633
85634
85635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
85636   int jresult ;
85637   int result;
85638
85639   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
85640   jresult = (int)result;
85641   return jresult;
85642 }
85643
85644
85645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
85646   int jresult ;
85647   int result;
85648
85649   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
85650   jresult = (int)result;
85651   return jresult;
85652 }
85653
85654
85655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
85656   int jresult ;
85657   int result;
85658
85659   result = (int)Dali::Toolkit::Slider::Property::MARKS;
85660   jresult = (int)result;
85661   return jresult;
85662 }
85663
85664
85665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
85666   int jresult ;
85667   int result;
85668
85669   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
85670   jresult = (int)result;
85671   return jresult;
85672 }
85673
85674
85675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
85676   int jresult ;
85677   int result;
85678
85679   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
85680   jresult = (int)result;
85681   return jresult;
85682 }
85683
85684
85685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
85686   void * jresult ;
85687   Dali::Toolkit::Slider::Property *result = 0 ;
85688
85689   {
85690     try {
85691       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
85692     } catch (std::out_of_range& e) {
85693       {
85694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85695       };
85696     } catch (std::exception& e) {
85697       {
85698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85699       };
85700     } catch (Dali::DaliException e) {
85701       {
85702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85703       };
85704     } catch (...) {
85705       {
85706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85707       };
85708     }
85709   }
85710
85711   jresult = (void *)result;
85712   return jresult;
85713 }
85714
85715
85716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
85717   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
85718
85719   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
85720   {
85721     try {
85722       delete arg1;
85723     } catch (std::out_of_range& e) {
85724       {
85725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85726       };
85727     } catch (std::exception& e) {
85728       {
85729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85730       };
85731     } catch (Dali::DaliException e) {
85732       {
85733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85734       };
85735     } catch (...) {
85736       {
85737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85738       };
85739     }
85740   }
85741
85742 }
85743
85744
85745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
85746   void * jresult ;
85747   Dali::Toolkit::Slider result;
85748
85749   {
85750     try {
85751       result = Dali::Toolkit::Slider::New();
85752     } catch (std::out_of_range& e) {
85753       {
85754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85755       };
85756     } catch (std::exception& e) {
85757       {
85758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85759       };
85760     } catch (Dali::DaliException e) {
85761       {
85762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85763       };
85764     } catch (...) {
85765       {
85766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85767       };
85768     }
85769   }
85770
85771   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
85772   return jresult;
85773 }
85774
85775
85776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
85777   void * jresult ;
85778   Dali::Toolkit::Slider *result = 0 ;
85779
85780   {
85781     try {
85782       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
85783     } catch (std::out_of_range& e) {
85784       {
85785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85786       };
85787     } catch (std::exception& e) {
85788       {
85789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85790       };
85791     } catch (Dali::DaliException e) {
85792       {
85793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85794       };
85795     } catch (...) {
85796       {
85797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85798       };
85799     }
85800   }
85801
85802   jresult = (void *)result;
85803   return jresult;
85804 }
85805
85806
85807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
85808   void * jresult ;
85809   Dali::Toolkit::Slider *arg1 = 0 ;
85810   Dali::Toolkit::Slider *result = 0 ;
85811
85812   arg1 = (Dali::Toolkit::Slider *)jarg1;
85813   if (!arg1) {
85814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
85815     return 0;
85816   }
85817   {
85818     try {
85819       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
85820     } catch (std::out_of_range& e) {
85821       {
85822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85823       };
85824     } catch (std::exception& e) {
85825       {
85826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85827       };
85828     } catch (Dali::DaliException e) {
85829       {
85830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85831       };
85832     } catch (...) {
85833       {
85834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85835       };
85836     }
85837   }
85838
85839   jresult = (void *)result;
85840   return jresult;
85841 }
85842
85843
85844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
85845   void * jresult ;
85846   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85847   Dali::Toolkit::Slider *arg2 = 0 ;
85848   Dali::Toolkit::Slider *result = 0 ;
85849
85850   arg1 = (Dali::Toolkit::Slider *)jarg1;
85851   arg2 = (Dali::Toolkit::Slider *)jarg2;
85852   if (!arg2) {
85853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
85854     return 0;
85855   }
85856   {
85857     try {
85858       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
85859     } catch (std::out_of_range& e) {
85860       {
85861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85862       };
85863     } catch (std::exception& e) {
85864       {
85865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85866       };
85867     } catch (Dali::DaliException e) {
85868       {
85869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85870       };
85871     } catch (...) {
85872       {
85873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85874       };
85875     }
85876   }
85877
85878   jresult = (void *)result;
85879   return jresult;
85880 }
85881
85882
85883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
85884   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85885
85886   arg1 = (Dali::Toolkit::Slider *)jarg1;
85887   {
85888     try {
85889       delete arg1;
85890     } catch (std::out_of_range& e) {
85891       {
85892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85893       };
85894     } catch (std::exception& e) {
85895       {
85896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85897       };
85898     } catch (Dali::DaliException e) {
85899       {
85900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85901       };
85902     } catch (...) {
85903       {
85904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85905       };
85906     }
85907   }
85908
85909 }
85910
85911
85912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
85913   void * jresult ;
85914   Dali::BaseHandle arg1 ;
85915   Dali::BaseHandle *argp1 ;
85916   Dali::Toolkit::Slider result;
85917
85918   argp1 = (Dali::BaseHandle *)jarg1;
85919   if (!argp1) {
85920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85921     return 0;
85922   }
85923   arg1 = *argp1;
85924   {
85925     try {
85926       result = Dali::Toolkit::Slider::DownCast(arg1);
85927     } catch (std::out_of_range& e) {
85928       {
85929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85930       };
85931     } catch (std::exception& e) {
85932       {
85933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85934       };
85935     } catch (Dali::DaliException e) {
85936       {
85937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85938       };
85939     } catch (...) {
85940       {
85941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85942       };
85943     }
85944   }
85945
85946   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
85947   return jresult;
85948 }
85949
85950
85951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
85952   void * jresult ;
85953   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85954   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
85955
85956   arg1 = (Dali::Toolkit::Slider *)jarg1;
85957   {
85958     try {
85959       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
85960     } catch (std::out_of_range& e) {
85961       {
85962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85963       };
85964     } catch (std::exception& e) {
85965       {
85966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85967       };
85968     } catch (Dali::DaliException e) {
85969       {
85970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85971       };
85972     } catch (...) {
85973       {
85974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85975       };
85976     }
85977   }
85978
85979   jresult = (void *)result;
85980   return jresult;
85981 }
85982
85983
85984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
85985   void * jresult ;
85986   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85987   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
85988
85989   arg1 = (Dali::Toolkit::Slider *)jarg1;
85990   {
85991     try {
85992       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
85993     } catch (std::out_of_range& e) {
85994       {
85995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85996       };
85997     } catch (std::exception& e) {
85998       {
85999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86000       };
86001     } catch (Dali::DaliException e) {
86002       {
86003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86004       };
86005     } catch (...) {
86006       {
86007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86008       };
86009     }
86010   }
86011
86012   jresult = (void *)result;
86013   return jresult;
86014 }
86015
86016
86017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
86018   void * jresult ;
86019   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86020   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
86021
86022   arg1 = (Dali::Toolkit::Slider *)jarg1;
86023   {
86024     try {
86025       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
86026     } catch (std::out_of_range& e) {
86027       {
86028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86029       };
86030     } catch (std::exception& e) {
86031       {
86032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86033       };
86034     } catch (Dali::DaliException e) {
86035       {
86036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86037       };
86038     } catch (...) {
86039       {
86040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86041       };
86042     }
86043   }
86044
86045   jresult = (void *)result;
86046   return jresult;
86047 }
86048
86049
86050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
86051   int jresult ;
86052   int result;
86053
86054   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
86055   jresult = (int)result;
86056   return jresult;
86057 }
86058
86059
86060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
86061   int jresult ;
86062   int result;
86063
86064   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
86065   jresult = (int)result;
86066   return jresult;
86067 }
86068
86069
86070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
86071   int jresult ;
86072   int result;
86073
86074   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
86075   jresult = (int)result;
86076   return jresult;
86077 }
86078
86079
86080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
86081   int jresult ;
86082   int result;
86083
86084   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
86085   jresult = (int)result;
86086   return jresult;
86087 }
86088
86089
86090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
86091   int result;
86092
86093   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
86094
86095   return result;
86096 }
86097
86098
86099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
86100   void * jresult ;
86101   Dali::Toolkit::VideoView::Property *result = 0 ;
86102
86103   {
86104     try {
86105       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
86106     } catch (std::out_of_range& e) {
86107       {
86108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86109       };
86110     } catch (std::exception& e) {
86111       {
86112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86113       };
86114     } catch (Dali::DaliException e) {
86115       {
86116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86117       };
86118     } catch (...) {
86119       {
86120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86121       };
86122     }
86123   }
86124
86125   jresult = (void *)result;
86126   return jresult;
86127 }
86128
86129
86130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
86131   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
86132
86133   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
86134   {
86135     try {
86136       delete arg1;
86137     } catch (std::out_of_range& e) {
86138       {
86139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86140       };
86141     } catch (std::exception& e) {
86142       {
86143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86144       };
86145     } catch (Dali::DaliException e) {
86146       {
86147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86148       };
86149     } catch (...) {
86150       {
86151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86152       };
86153     }
86154   }
86155
86156 }
86157
86158
86159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
86160   void * jresult ;
86161   Dali::Toolkit::VideoView result;
86162
86163   {
86164     try {
86165       result = Dali::Toolkit::VideoView::New();
86166     } catch (std::out_of_range& e) {
86167       {
86168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86169       };
86170     } catch (std::exception& e) {
86171       {
86172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86173       };
86174     } catch (Dali::DaliException e) {
86175       {
86176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86177       };
86178     } catch (...) {
86179       {
86180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86181       };
86182     }
86183   }
86184
86185   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
86186   return jresult;
86187 }
86188
86189
86190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
86191   void * jresult ;
86192   std::string *arg1 = 0 ;
86193   Dali::Toolkit::VideoView result;
86194
86195   if (!jarg1) {
86196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86197     return 0;
86198   }
86199   std::string arg1_str(jarg1);
86200   arg1 = &arg1_str;
86201   {
86202     try {
86203       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
86204     } catch (std::out_of_range& e) {
86205       {
86206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86207       };
86208     } catch (std::exception& e) {
86209       {
86210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86211       };
86212     } catch (Dali::DaliException e) {
86213       {
86214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86215       };
86216     } catch (...) {
86217       {
86218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86219       };
86220     }
86221   }
86222
86223   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
86224
86225   //argout typemap for const std::string&
86226
86227   return jresult;
86228 }
86229
86230
86231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) {
86232   void * jresult ;
86233   Dali::Toolkit::VideoView result;
86234   {
86235     try {
86236       result = Dali::Toolkit::VideoView::New(swCodec);
86237     } catch (std::out_of_range& e) {
86238       {
86239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86240       };
86241     } catch (std::exception& e) {
86242       {
86243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86244       };
86245     } catch (Dali::DaliException e) {
86246       {
86247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86248       };
86249     } catch (...) {
86250       {
86251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86252       };
86253     }
86254   }
86255
86256   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
86257
86258   //argout typemap for const std::string&
86259
86260   return jresult;
86261 }
86262
86263
86264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_3(char * jarg1, bool swCodec) {
86265   void * jresult ;
86266   std::string *arg1 = 0 ;
86267   Dali::Toolkit::VideoView result;
86268
86269   if (!jarg1) {
86270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86271     return 0;
86272   }
86273   std::string arg1_str(jarg1);
86274   arg1 = &arg1_str;
86275   {
86276     try {
86277       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec);
86278     } catch (std::out_of_range& e) {
86279       {
86280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86281       };
86282     } catch (std::exception& e) {
86283       {
86284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86285       };
86286     } catch (Dali::DaliException e) {
86287       {
86288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86289       };
86290     } catch (...) {
86291       {
86292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86293       };
86294     }
86295   }
86296
86297   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
86298
86299   //argout typemap for const std::string&
86300
86301   return jresult;
86302 }
86303
86304
86305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
86306   void * jresult ;
86307   Dali::Toolkit::VideoView *result = 0 ;
86308
86309   {
86310     try {
86311       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
86312     } catch (std::out_of_range& e) {
86313       {
86314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86315       };
86316     } catch (std::exception& e) {
86317       {
86318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86319       };
86320     } catch (Dali::DaliException e) {
86321       {
86322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86323       };
86324     } catch (...) {
86325       {
86326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86327       };
86328     }
86329   }
86330
86331   jresult = (void *)result;
86332   return jresult;
86333 }
86334
86335
86336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
86337   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86338
86339   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86340   {
86341     try {
86342       delete arg1;
86343     } catch (std::out_of_range& e) {
86344       {
86345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86346       };
86347     } catch (std::exception& e) {
86348       {
86349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86350       };
86351     } catch (Dali::DaliException e) {
86352       {
86353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86354       };
86355     } catch (...) {
86356       {
86357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86358       };
86359     }
86360   }
86361
86362 }
86363
86364
86365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
86366   void * jresult ;
86367   Dali::Toolkit::VideoView *arg1 = 0 ;
86368   Dali::Toolkit::VideoView *result = 0 ;
86369
86370   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86371   if (!arg1) {
86372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
86373     return 0;
86374   }
86375   {
86376     try {
86377       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
86378     } catch (std::out_of_range& e) {
86379       {
86380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86381       };
86382     } catch (std::exception& e) {
86383       {
86384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86385       };
86386     } catch (Dali::DaliException e) {
86387       {
86388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86389       };
86390     } catch (...) {
86391       {
86392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86393       };
86394     }
86395   }
86396
86397   jresult = (void *)result;
86398   return jresult;
86399 }
86400
86401
86402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
86403   void * jresult ;
86404   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86405   Dali::Toolkit::VideoView *arg2 = 0 ;
86406   Dali::Toolkit::VideoView *result = 0 ;
86407
86408   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86409   arg2 = (Dali::Toolkit::VideoView *)jarg2;
86410   if (!arg2) {
86411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
86412     return 0;
86413   }
86414   {
86415     try {
86416       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
86417     } catch (std::out_of_range& e) {
86418       {
86419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86420       };
86421     } catch (std::exception& e) {
86422       {
86423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86424       };
86425     } catch (Dali::DaliException e) {
86426       {
86427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86428       };
86429     } catch (...) {
86430       {
86431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86432       };
86433     }
86434   }
86435
86436   jresult = (void *)result;
86437   return jresult;
86438 }
86439
86440
86441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
86442   void * jresult ;
86443   Dali::BaseHandle arg1 ;
86444   Dali::BaseHandle *argp1 ;
86445   Dali::Toolkit::VideoView result;
86446
86447   argp1 = (Dali::BaseHandle *)jarg1;
86448   if (!argp1) {
86449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86450     return 0;
86451   }
86452   arg1 = *argp1;
86453   {
86454     try {
86455       result = Dali::Toolkit::VideoView::DownCast(arg1);
86456     } catch (std::out_of_range& e) {
86457       {
86458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86459       };
86460     } catch (std::exception& e) {
86461       {
86462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86463       };
86464     } catch (Dali::DaliException e) {
86465       {
86466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86467       };
86468     } catch (...) {
86469       {
86470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86471       };
86472     }
86473   }
86474
86475   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
86476   return jresult;
86477 }
86478
86479
86480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
86481   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86482
86483   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86484   {
86485     try {
86486       (arg1)->Play();
86487     } catch (std::out_of_range& e) {
86488       {
86489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86490       };
86491     } catch (std::exception& e) {
86492       {
86493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86494       };
86495     } catch (Dali::DaliException e) {
86496       {
86497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86498       };
86499     } catch (...) {
86500       {
86501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86502       };
86503     }
86504   }
86505
86506 }
86507
86508
86509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
86510   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86511
86512   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86513   {
86514     try {
86515       (arg1)->Pause();
86516     } catch (std::out_of_range& e) {
86517       {
86518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86519       };
86520     } catch (std::exception& e) {
86521       {
86522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86523       };
86524     } catch (Dali::DaliException e) {
86525       {
86526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86527       };
86528     } catch (...) {
86529       {
86530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86531       };
86532     }
86533   }
86534
86535 }
86536
86537
86538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
86539   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86540
86541   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86542   {
86543     try {
86544       (arg1)->Stop();
86545     } catch (std::out_of_range& e) {
86546       {
86547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86548       };
86549     } catch (std::exception& e) {
86550       {
86551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86552       };
86553     } catch (Dali::DaliException e) {
86554       {
86555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86556       };
86557     } catch (...) {
86558       {
86559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86560       };
86561     }
86562   }
86563
86564 }
86565
86566
86567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
86568   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86569   int arg2 ;
86570
86571   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86572   arg2 = (int)jarg2;
86573   {
86574     try {
86575       (arg1)->Forward(arg2);
86576     } catch (std::out_of_range& e) {
86577       {
86578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86579       };
86580     } catch (std::exception& e) {
86581       {
86582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86583       };
86584     } catch (Dali::DaliException e) {
86585       {
86586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86587       };
86588     } catch (...) {
86589       {
86590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86591       };
86592     }
86593   }
86594
86595 }
86596
86597
86598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
86599   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86600   int arg2 ;
86601
86602   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86603   arg2 = (int)jarg2;
86604   {
86605     try {
86606       (arg1)->Backward(arg2);
86607     } catch (std::out_of_range& e) {
86608       {
86609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86610       };
86611     } catch (std::exception& e) {
86612       {
86613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86614       };
86615     } catch (Dali::DaliException e) {
86616       {
86617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86618       };
86619     } catch (...) {
86620       {
86621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86622       };
86623     }
86624   }
86625
86626 }
86627
86628
86629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
86630   void * jresult ;
86631   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86632   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
86633
86634   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86635   {
86636     try {
86637       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
86638     } catch (std::out_of_range& e) {
86639       {
86640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86641       };
86642     } catch (std::exception& e) {
86643       {
86644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86645       };
86646     } catch (Dali::DaliException e) {
86647       {
86648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86649       };
86650     } catch (...) {
86651       {
86652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86653       };
86654     }
86655   }
86656
86657   jresult = (void *)result;
86658   return jresult;
86659 }
86660
86661
86662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
86663   int jresult ;
86664   int result;
86665
86666   result = (int)Dali::Toolkit::Popup::Property::TITLE;
86667   jresult = (int)result;
86668   return jresult;
86669 }
86670
86671
86672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
86673   int jresult ;
86674   int result;
86675
86676   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
86677   jresult = (int)result;
86678   return jresult;
86679 }
86680
86681
86682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
86683   int jresult ;
86684   int result;
86685
86686   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
86687   jresult = (int)result;
86688   return jresult;
86689 }
86690
86691
86692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
86693   int jresult ;
86694   int result;
86695
86696   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
86697   jresult = (int)result;
86698   return jresult;
86699 }
86700
86701
86702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
86703   int jresult ;
86704   int result;
86705
86706   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
86707   jresult = (int)result;
86708   return jresult;
86709 }
86710
86711
86712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
86713   int jresult ;
86714   int result;
86715
86716   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
86717   jresult = (int)result;
86718   return jresult;
86719 }
86720
86721
86722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
86723   int jresult ;
86724   int result;
86725
86726   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
86727   jresult = (int)result;
86728   return jresult;
86729 }
86730
86731
86732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
86733   int jresult ;
86734   int result;
86735
86736   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
86737   jresult = (int)result;
86738   return jresult;
86739 }
86740
86741
86742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
86743   int jresult ;
86744   int result;
86745
86746   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
86747   jresult = (int)result;
86748   return jresult;
86749 }
86750
86751
86752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
86753   int jresult ;
86754   int result;
86755
86756   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
86757   jresult = (int)result;
86758   return jresult;
86759 }
86760
86761
86762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
86763   int jresult ;
86764   int result;
86765
86766   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
86767   jresult = (int)result;
86768   return jresult;
86769 }
86770
86771
86772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
86773   int jresult ;
86774   int result;
86775
86776   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
86777   jresult = (int)result;
86778   return jresult;
86779 }
86780
86781
86782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
86783   int jresult ;
86784   int result;
86785
86786   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
86787   jresult = (int)result;
86788   return jresult;
86789 }
86790
86791
86792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
86793   int jresult ;
86794   int result;
86795
86796   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
86797   jresult = (int)result;
86798   return jresult;
86799 }
86800
86801
86802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
86803   int jresult ;
86804   int result;
86805
86806   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
86807   jresult = (int)result;
86808   return jresult;
86809 }
86810
86811
86812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
86813   int jresult ;
86814   int result;
86815
86816   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
86817   jresult = (int)result;
86818   return jresult;
86819 }
86820
86821
86822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
86823   int jresult ;
86824   int result;
86825
86826   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
86827   jresult = (int)result;
86828   return jresult;
86829 }
86830
86831
86832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
86833   int jresult ;
86834   int result;
86835
86836   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
86837   jresult = (int)result;
86838   return jresult;
86839 }
86840
86841
86842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
86843   int jresult ;
86844   int result;
86845
86846   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
86847   jresult = (int)result;
86848   return jresult;
86849 }
86850
86851
86852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
86853   int jresult ;
86854   int result;
86855
86856   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
86857   jresult = (int)result;
86858   return jresult;
86859 }
86860
86861
86862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
86863   int jresult ;
86864   int result;
86865
86866   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
86867   jresult = (int)result;
86868   return jresult;
86869 }
86870
86871
86872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
86873   void * jresult ;
86874   Dali::Toolkit::Popup::Property *result = 0 ;
86875
86876   {
86877     try {
86878       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
86879     } catch (std::out_of_range& e) {
86880       {
86881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86882       };
86883     } catch (std::exception& e) {
86884       {
86885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86886       };
86887     } catch (Dali::DaliException e) {
86888       {
86889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86890       };
86891     } catch (...) {
86892       {
86893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86894       };
86895     }
86896   }
86897
86898   jresult = (void *)result;
86899   return jresult;
86900 }
86901
86902
86903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
86904   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
86905
86906   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
86907   {
86908     try {
86909       delete arg1;
86910     } catch (std::out_of_range& e) {
86911       {
86912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86913       };
86914     } catch (std::exception& e) {
86915       {
86916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86917       };
86918     } catch (Dali::DaliException e) {
86919       {
86920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86921       };
86922     } catch (...) {
86923       {
86924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86925       };
86926     }
86927   }
86928
86929 }
86930
86931
86932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
86933   void * jresult ;
86934   Dali::Toolkit::Popup *result = 0 ;
86935
86936   {
86937     try {
86938       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
86939     } catch (std::out_of_range& e) {
86940       {
86941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86942       };
86943     } catch (std::exception& e) {
86944       {
86945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86946       };
86947     } catch (Dali::DaliException e) {
86948       {
86949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86950       };
86951     } catch (...) {
86952       {
86953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86954       };
86955     }
86956   }
86957
86958   jresult = (void *)result;
86959   return jresult;
86960 }
86961
86962
86963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
86964   void * jresult ;
86965   Dali::Toolkit::Popup result;
86966
86967   {
86968     try {
86969       result = Dali::Toolkit::Popup::New();
86970     } catch (std::out_of_range& e) {
86971       {
86972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86973       };
86974     } catch (std::exception& e) {
86975       {
86976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86977       };
86978     } catch (Dali::DaliException e) {
86979       {
86980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86981       };
86982     } catch (...) {
86983       {
86984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86985       };
86986     }
86987   }
86988
86989   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
86990   return jresult;
86991 }
86992
86993
86994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
86995   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
86996
86997   arg1 = (Dali::Toolkit::Popup *)jarg1;
86998   {
86999     try {
87000       delete arg1;
87001     } catch (std::out_of_range& e) {
87002       {
87003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87004       };
87005     } catch (std::exception& e) {
87006       {
87007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87008       };
87009     } catch (Dali::DaliException e) {
87010       {
87011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87012       };
87013     } catch (...) {
87014       {
87015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87016       };
87017     }
87018   }
87019
87020 }
87021
87022
87023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
87024   void * jresult ;
87025   Dali::Toolkit::Popup *arg1 = 0 ;
87026   Dali::Toolkit::Popup *result = 0 ;
87027
87028   arg1 = (Dali::Toolkit::Popup *)jarg1;
87029   if (!arg1) {
87030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
87031     return 0;
87032   }
87033   {
87034     try {
87035       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
87036     } catch (std::out_of_range& e) {
87037       {
87038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87039       };
87040     } catch (std::exception& e) {
87041       {
87042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87043       };
87044     } catch (Dali::DaliException e) {
87045       {
87046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87047       };
87048     } catch (...) {
87049       {
87050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87051       };
87052     }
87053   }
87054
87055   jresult = (void *)result;
87056   return jresult;
87057 }
87058
87059
87060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
87061   void * jresult ;
87062   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87063   Dali::Toolkit::Popup *arg2 = 0 ;
87064   Dali::Toolkit::Popup *result = 0 ;
87065
87066   arg1 = (Dali::Toolkit::Popup *)jarg1;
87067   arg2 = (Dali::Toolkit::Popup *)jarg2;
87068   if (!arg2) {
87069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
87070     return 0;
87071   }
87072   {
87073     try {
87074       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
87075     } catch (std::out_of_range& e) {
87076       {
87077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87078       };
87079     } catch (std::exception& e) {
87080       {
87081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87082       };
87083     } catch (Dali::DaliException e) {
87084       {
87085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87086       };
87087     } catch (...) {
87088       {
87089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87090       };
87091     }
87092   }
87093
87094   jresult = (void *)result;
87095   return jresult;
87096 }
87097
87098
87099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
87100   void * jresult ;
87101   Dali::BaseHandle arg1 ;
87102   Dali::BaseHandle *argp1 ;
87103   Dali::Toolkit::Popup result;
87104
87105   argp1 = (Dali::BaseHandle *)jarg1;
87106   if (!argp1) {
87107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87108     return 0;
87109   }
87110   arg1 = *argp1;
87111   {
87112     try {
87113       result = Dali::Toolkit::Popup::DownCast(arg1);
87114     } catch (std::out_of_range& e) {
87115       {
87116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87117       };
87118     } catch (std::exception& e) {
87119       {
87120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87121       };
87122     } catch (Dali::DaliException e) {
87123       {
87124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87125       };
87126     } catch (...) {
87127       {
87128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87129       };
87130     }
87131   }
87132
87133   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
87134   return jresult;
87135 }
87136
87137
87138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
87139   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87140   Dali::Actor arg2 ;
87141   Dali::Actor *argp2 ;
87142
87143   arg1 = (Dali::Toolkit::Popup *)jarg1;
87144   argp2 = (Dali::Actor *)jarg2;
87145   if (!argp2) {
87146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87147     return ;
87148   }
87149   arg2 = *argp2;
87150   {
87151     try {
87152       (arg1)->SetTitle(arg2);
87153     } catch (std::out_of_range& e) {
87154       {
87155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87156       };
87157     } catch (std::exception& e) {
87158       {
87159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87160       };
87161     } catch (Dali::DaliException e) {
87162       {
87163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87164       };
87165     } catch (...) {
87166       {
87167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87168       };
87169     }
87170   }
87171
87172 }
87173
87174
87175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
87176   void * jresult ;
87177   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87178   Dali::Actor result;
87179
87180   arg1 = (Dali::Toolkit::Popup *)jarg1;
87181   {
87182     try {
87183       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
87184     } catch (std::out_of_range& e) {
87185       {
87186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87187       };
87188     } catch (std::exception& e) {
87189       {
87190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87191       };
87192     } catch (Dali::DaliException e) {
87193       {
87194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87195       };
87196     } catch (...) {
87197       {
87198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87199       };
87200     }
87201   }
87202
87203   jresult = new Dali::Actor((const Dali::Actor &)result);
87204   return jresult;
87205 }
87206
87207
87208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
87209   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87210   Dali::Actor arg2 ;
87211   Dali::Actor *argp2 ;
87212
87213   arg1 = (Dali::Toolkit::Popup *)jarg1;
87214   argp2 = (Dali::Actor *)jarg2;
87215   if (!argp2) {
87216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87217     return ;
87218   }
87219   arg2 = *argp2;
87220   {
87221     try {
87222       (arg1)->SetContent(arg2);
87223     } catch (std::out_of_range& e) {
87224       {
87225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87226       };
87227     } catch (std::exception& e) {
87228       {
87229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87230       };
87231     } catch (Dali::DaliException e) {
87232       {
87233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87234       };
87235     } catch (...) {
87236       {
87237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87238       };
87239     }
87240   }
87241
87242 }
87243
87244
87245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
87246   void * jresult ;
87247   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87248   Dali::Actor result;
87249
87250   arg1 = (Dali::Toolkit::Popup *)jarg1;
87251   {
87252     try {
87253       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
87254     } catch (std::out_of_range& e) {
87255       {
87256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87257       };
87258     } catch (std::exception& e) {
87259       {
87260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87261       };
87262     } catch (Dali::DaliException e) {
87263       {
87264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87265       };
87266     } catch (...) {
87267       {
87268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87269       };
87270     }
87271   }
87272
87273   jresult = new Dali::Actor((const Dali::Actor &)result);
87274   return jresult;
87275 }
87276
87277
87278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
87279   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87280   Dali::Actor arg2 ;
87281   Dali::Actor *argp2 ;
87282
87283   arg1 = (Dali::Toolkit::Popup *)jarg1;
87284   argp2 = (Dali::Actor *)jarg2;
87285   if (!argp2) {
87286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87287     return ;
87288   }
87289   arg2 = *argp2;
87290   {
87291     try {
87292       (arg1)->SetFooter(arg2);
87293     } catch (std::out_of_range& e) {
87294       {
87295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87296       };
87297     } catch (std::exception& e) {
87298       {
87299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87300       };
87301     } catch (Dali::DaliException e) {
87302       {
87303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87304       };
87305     } catch (...) {
87306       {
87307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87308       };
87309     }
87310   }
87311
87312 }
87313
87314
87315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
87316   void * jresult ;
87317   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87318   Dali::Actor result;
87319
87320   arg1 = (Dali::Toolkit::Popup *)jarg1;
87321   {
87322     try {
87323       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
87324     } catch (std::out_of_range& e) {
87325       {
87326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87327       };
87328     } catch (std::exception& e) {
87329       {
87330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87331       };
87332     } catch (Dali::DaliException e) {
87333       {
87334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87335       };
87336     } catch (...) {
87337       {
87338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87339       };
87340     }
87341   }
87342
87343   jresult = new Dali::Actor((const Dali::Actor &)result);
87344   return jresult;
87345 }
87346
87347
87348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
87349   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87350   Dali::Toolkit::Popup::DisplayState arg2 ;
87351
87352   arg1 = (Dali::Toolkit::Popup *)jarg1;
87353   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
87354   {
87355     try {
87356       (arg1)->SetDisplayState(arg2);
87357     } catch (std::out_of_range& e) {
87358       {
87359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87360       };
87361     } catch (std::exception& e) {
87362       {
87363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87364       };
87365     } catch (Dali::DaliException e) {
87366       {
87367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87368       };
87369     } catch (...) {
87370       {
87371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87372       };
87373     }
87374   }
87375
87376 }
87377
87378
87379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
87380   int jresult ;
87381   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87382   Dali::Toolkit::Popup::DisplayState result;
87383
87384   arg1 = (Dali::Toolkit::Popup *)jarg1;
87385   {
87386     try {
87387       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
87388     } catch (std::out_of_range& e) {
87389       {
87390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87391       };
87392     } catch (std::exception& e) {
87393       {
87394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87395       };
87396     } catch (Dali::DaliException e) {
87397       {
87398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87399       };
87400     } catch (...) {
87401       {
87402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87403       };
87404     }
87405   }
87406
87407   jresult = (int)result;
87408   return jresult;
87409 }
87410
87411
87412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
87413   void * jresult ;
87414   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87415   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
87416
87417   arg1 = (Dali::Toolkit::Popup *)jarg1;
87418   {
87419     try {
87420       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
87421     } catch (std::out_of_range& e) {
87422       {
87423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87424       };
87425     } catch (std::exception& e) {
87426       {
87427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87428       };
87429     } catch (Dali::DaliException e) {
87430       {
87431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87432       };
87433     } catch (...) {
87434       {
87435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87436       };
87437     }
87438   }
87439
87440   jresult = (void *)result;
87441   return jresult;
87442 }
87443
87444
87445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
87446   void * jresult ;
87447   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87448   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87449
87450   arg1 = (Dali::Toolkit::Popup *)jarg1;
87451   {
87452     try {
87453       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
87454     } catch (std::out_of_range& e) {
87455       {
87456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87457       };
87458     } catch (std::exception& e) {
87459       {
87460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87461       };
87462     } catch (Dali::DaliException e) {
87463       {
87464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87465       };
87466     } catch (...) {
87467       {
87468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87469       };
87470     }
87471   }
87472
87473   jresult = (void *)result;
87474   return jresult;
87475 }
87476
87477
87478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
87479   void * jresult ;
87480   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87481   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87482
87483   arg1 = (Dali::Toolkit::Popup *)jarg1;
87484   {
87485     try {
87486       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
87487     } catch (std::out_of_range& e) {
87488       {
87489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87490       };
87491     } catch (std::exception& e) {
87492       {
87493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87494       };
87495     } catch (Dali::DaliException e) {
87496       {
87497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87498       };
87499     } catch (...) {
87500       {
87501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87502       };
87503     }
87504   }
87505
87506   jresult = (void *)result;
87507   return jresult;
87508 }
87509
87510
87511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
87512   void * jresult ;
87513   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87514   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87515
87516   arg1 = (Dali::Toolkit::Popup *)jarg1;
87517   {
87518     try {
87519       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
87520     } catch (std::out_of_range& e) {
87521       {
87522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87523       };
87524     } catch (std::exception& e) {
87525       {
87526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87527       };
87528     } catch (Dali::DaliException e) {
87529       {
87530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87531       };
87532     } catch (...) {
87533       {
87534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87535       };
87536     }
87537   }
87538
87539   jresult = (void *)result;
87540   return jresult;
87541 }
87542
87543
87544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
87545   void * jresult ;
87546   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87547   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87548
87549   arg1 = (Dali::Toolkit::Popup *)jarg1;
87550   {
87551     try {
87552       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
87553     } catch (std::out_of_range& e) {
87554       {
87555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87556       };
87557     } catch (std::exception& e) {
87558       {
87559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87560       };
87561     } catch (Dali::DaliException e) {
87562       {
87563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87564       };
87565     } catch (...) {
87566       {
87567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87568       };
87569     }
87570   }
87571
87572   jresult = (void *)result;
87573   return jresult;
87574 }
87575
87576
87577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
87578   int jresult ;
87579   int result;
87580
87581   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
87582   jresult = (int)result;
87583   return jresult;
87584 }
87585
87586
87587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
87588   int jresult ;
87589   int result;
87590
87591   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
87592   jresult = (int)result;
87593   return jresult;
87594 }
87595
87596
87597 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
87598   int jresult ;
87599   int result;
87600
87601   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
87602   jresult = (int)result;
87603   return jresult;
87604 }
87605
87606
87607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
87608   int jresult ;
87609   int result;
87610
87611   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
87612   jresult = (int)result;
87613   return jresult;
87614 }
87615
87616
87617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
87618   int jresult ;
87619   int result;
87620
87621   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
87622   jresult = (int)result;
87623   return jresult;
87624 }
87625
87626
87627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
87628   int jresult ;
87629   int result;
87630
87631   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
87632   jresult = (int)result;
87633   return jresult;
87634 }
87635
87636
87637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
87638   int jresult ;
87639   int result;
87640
87641   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
87642   jresult = (int)result;
87643   return jresult;
87644 }
87645
87646
87647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
87648   int jresult ;
87649   int result;
87650
87651   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
87652   jresult = (int)result;
87653   return jresult;
87654 }
87655
87656
87657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
87658   int jresult ;
87659   int result;
87660
87661   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
87662   jresult = (int)result;
87663   return jresult;
87664 }
87665
87666
87667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
87668   void * jresult ;
87669   Dali::Toolkit::ProgressBar::Property *result = 0 ;
87670
87671   {
87672     try {
87673       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
87674     } catch (std::out_of_range& e) {
87675       {
87676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87677       };
87678     } catch (std::exception& e) {
87679       {
87680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87681       };
87682     } catch (Dali::DaliException e) {
87683       {
87684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87685       };
87686     } catch (...) {
87687       {
87688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87689       };
87690     }
87691   }
87692
87693   jresult = (void *)result;
87694   return jresult;
87695 }
87696
87697
87698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
87699   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
87700
87701   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
87702   {
87703     try {
87704       delete arg1;
87705     } catch (std::out_of_range& e) {
87706       {
87707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87708       };
87709     } catch (std::exception& e) {
87710       {
87711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87712       };
87713     } catch (Dali::DaliException e) {
87714       {
87715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87716       };
87717     } catch (...) {
87718       {
87719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87720       };
87721     }
87722   }
87723
87724 }
87725
87726
87727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
87728   void * jresult ;
87729   Dali::Toolkit::ProgressBar result;
87730
87731   {
87732     try {
87733       result = Dali::Toolkit::ProgressBar::New();
87734     } catch (std::out_of_range& e) {
87735       {
87736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87737       };
87738     } catch (std::exception& e) {
87739       {
87740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87741       };
87742     } catch (Dali::DaliException e) {
87743       {
87744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87745       };
87746     } catch (...) {
87747       {
87748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87749       };
87750     }
87751   }
87752
87753   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
87754   return jresult;
87755 }
87756
87757
87758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
87759   void * jresult ;
87760   Dali::Toolkit::ProgressBar *result = 0 ;
87761
87762   {
87763     try {
87764       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
87765     } catch (std::out_of_range& e) {
87766       {
87767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87768       };
87769     } catch (std::exception& e) {
87770       {
87771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87772       };
87773     } catch (Dali::DaliException e) {
87774       {
87775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87776       };
87777     } catch (...) {
87778       {
87779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87780       };
87781     }
87782   }
87783
87784   jresult = (void *)result;
87785   return jresult;
87786 }
87787
87788
87789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
87790   void * jresult ;
87791   Dali::Toolkit::ProgressBar *arg1 = 0 ;
87792   Dali::Toolkit::ProgressBar *result = 0 ;
87793
87794   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87795   if (!arg1) {
87796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
87797     return 0;
87798   }
87799   {
87800     try {
87801       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
87802     } catch (std::out_of_range& e) {
87803       {
87804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87805       };
87806     } catch (std::exception& e) {
87807       {
87808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87809       };
87810     } catch (Dali::DaliException e) {
87811       {
87812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87813       };
87814     } catch (...) {
87815       {
87816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87817       };
87818     }
87819   }
87820
87821   jresult = (void *)result;
87822   return jresult;
87823 }
87824
87825
87826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
87827   void * jresult ;
87828   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
87829   Dali::Toolkit::ProgressBar *arg2 = 0 ;
87830   Dali::Toolkit::ProgressBar *result = 0 ;
87831
87832   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87833   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
87834   if (!arg2) {
87835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
87836     return 0;
87837   }
87838   {
87839     try {
87840       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
87841     } catch (std::out_of_range& e) {
87842       {
87843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87844       };
87845     } catch (std::exception& e) {
87846       {
87847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87848       };
87849     } catch (Dali::DaliException e) {
87850       {
87851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87852       };
87853     } catch (...) {
87854       {
87855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87856       };
87857     }
87858   }
87859
87860   jresult = (void *)result;
87861   return jresult;
87862 }
87863
87864
87865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
87866   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
87867
87868   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87869   {
87870     try {
87871       delete arg1;
87872     } catch (std::out_of_range& e) {
87873       {
87874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87875       };
87876     } catch (std::exception& e) {
87877       {
87878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87879       };
87880     } catch (Dali::DaliException e) {
87881       {
87882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87883       };
87884     } catch (...) {
87885       {
87886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87887       };
87888     }
87889   }
87890
87891 }
87892
87893
87894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
87895   void * jresult ;
87896   Dali::BaseHandle arg1 ;
87897   Dali::BaseHandle *argp1 ;
87898   Dali::Toolkit::ProgressBar result;
87899
87900   argp1 = (Dali::BaseHandle *)jarg1;
87901   if (!argp1) {
87902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87903     return 0;
87904   }
87905   arg1 = *argp1;
87906   {
87907     try {
87908       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
87909     } catch (std::out_of_range& e) {
87910       {
87911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87912       };
87913     } catch (std::exception& e) {
87914       {
87915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87916       };
87917     } catch (Dali::DaliException e) {
87918       {
87919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87920       };
87921     } catch (...) {
87922       {
87923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87924       };
87925     }
87926   }
87927
87928   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
87929   return jresult;
87930 }
87931
87932
87933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
87934   void * jresult ;
87935   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
87936   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
87937
87938   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87939   {
87940     try {
87941       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
87942     } catch (std::out_of_range& e) {
87943       {
87944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87945       };
87946     } catch (std::exception& e) {
87947       {
87948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87949       };
87950     } catch (Dali::DaliException e) {
87951       {
87952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87953       };
87954     } catch (...) {
87955       {
87956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87957       };
87958     }
87959   }
87960
87961   jresult = (void *)result;
87962   return jresult;
87963 }
87964
87965
87966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
87967   void * jresult ;
87968   Dali::Toolkit::GaussianBlurView *result = 0 ;
87969
87970   {
87971     try {
87972       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
87973     } catch (std::out_of_range& e) {
87974       {
87975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87976       };
87977     } catch (std::exception& e) {
87978       {
87979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87980       };
87981     } catch (Dali::DaliException e) {
87982       {
87983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87984       };
87985     } catch (...) {
87986       {
87987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87988       };
87989     }
87990   }
87991
87992   jresult = (void *)result;
87993   return jresult;
87994 }
87995
87996
87997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
87998   void * jresult ;
87999   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
88000   Dali::Toolkit::GaussianBlurView *result = 0 ;
88001
88002   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88003   if (!arg1) {
88004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
88005     return 0;
88006   }
88007   {
88008     try {
88009       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
88010     } catch (std::out_of_range& e) {
88011       {
88012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88013       };
88014     } catch (std::exception& e) {
88015       {
88016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88017       };
88018     } catch (Dali::DaliException e) {
88019       {
88020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88021       };
88022     } catch (...) {
88023       {
88024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88025       };
88026     }
88027   }
88028
88029   jresult = (void *)result;
88030   return jresult;
88031 }
88032
88033
88034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
88035   void * jresult ;
88036   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88037   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
88038   Dali::Toolkit::GaussianBlurView *result = 0 ;
88039
88040   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88041   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
88042   if (!arg2) {
88043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
88044     return 0;
88045   }
88046   {
88047     try {
88048       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
88049     } catch (std::out_of_range& e) {
88050       {
88051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88052       };
88053     } catch (std::exception& e) {
88054       {
88055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88056       };
88057     } catch (Dali::DaliException e) {
88058       {
88059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88060       };
88061     } catch (...) {
88062       {
88063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88064       };
88065     }
88066   }
88067
88068   jresult = (void *)result;
88069   return jresult;
88070 }
88071
88072
88073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
88074   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88075
88076   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88077   {
88078     try {
88079       delete arg1;
88080     } catch (std::out_of_range& e) {
88081       {
88082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88083       };
88084     } catch (std::exception& e) {
88085       {
88086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88087       };
88088     } catch (Dali::DaliException e) {
88089       {
88090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88091       };
88092     } catch (...) {
88093       {
88094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88095       };
88096     }
88097   }
88098
88099 }
88100
88101
88102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
88103   void * jresult ;
88104   Dali::BaseHandle arg1 ;
88105   Dali::BaseHandle *argp1 ;
88106   Dali::Toolkit::GaussianBlurView result;
88107
88108   argp1 = (Dali::BaseHandle *)jarg1;
88109   if (!argp1) {
88110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88111     return 0;
88112   }
88113   arg1 = *argp1;
88114   {
88115     try {
88116       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
88117     } catch (std::out_of_range& e) {
88118       {
88119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88120       };
88121     } catch (std::exception& e) {
88122       {
88123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88124       };
88125     } catch (Dali::DaliException e) {
88126       {
88127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88128       };
88129     } catch (...) {
88130       {
88131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88132       };
88133     }
88134   }
88135
88136   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88137   return jresult;
88138 }
88139
88140
88141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
88142   void * jresult ;
88143   Dali::Toolkit::GaussianBlurView result;
88144
88145   {
88146     try {
88147       result = Dali::Toolkit::GaussianBlurView::New();
88148     } catch (std::out_of_range& e) {
88149       {
88150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88151       };
88152     } catch (std::exception& e) {
88153       {
88154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88155       };
88156     } catch (Dali::DaliException e) {
88157       {
88158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88159       };
88160     } catch (...) {
88161       {
88162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88163       };
88164     }
88165   }
88166
88167   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88168   return jresult;
88169 }
88170
88171
88172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
88173   void * jresult ;
88174   unsigned int arg1 ;
88175   float arg2 ;
88176   Dali::Pixel::Format arg3 ;
88177   float arg4 ;
88178   float arg5 ;
88179   bool arg6 ;
88180   Dali::Toolkit::GaussianBlurView result;
88181
88182   arg1 = (unsigned int)jarg1;
88183   arg2 = (float)jarg2;
88184   arg3 = (Dali::Pixel::Format)jarg3;
88185   arg4 = (float)jarg4;
88186   arg5 = (float)jarg5;
88187   arg6 = jarg6 ? true : false;
88188   {
88189     try {
88190       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
88191     } catch (std::out_of_range& e) {
88192       {
88193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88194       };
88195     } catch (std::exception& e) {
88196       {
88197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88198       };
88199     } catch (Dali::DaliException e) {
88200       {
88201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88202       };
88203     } catch (...) {
88204       {
88205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88206       };
88207     }
88208   }
88209
88210   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88211   return jresult;
88212 }
88213
88214
88215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
88216   void * jresult ;
88217   unsigned int arg1 ;
88218   float arg2 ;
88219   Dali::Pixel::Format arg3 ;
88220   float arg4 ;
88221   float arg5 ;
88222   Dali::Toolkit::GaussianBlurView result;
88223
88224   arg1 = (unsigned int)jarg1;
88225   arg2 = (float)jarg2;
88226   arg3 = (Dali::Pixel::Format)jarg3;
88227   arg4 = (float)jarg4;
88228   arg5 = (float)jarg5;
88229   {
88230     try {
88231       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
88232     } catch (std::out_of_range& e) {
88233       {
88234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88235       };
88236     } catch (std::exception& e) {
88237       {
88238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88239       };
88240     } catch (Dali::DaliException e) {
88241       {
88242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88243       };
88244     } catch (...) {
88245       {
88246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88247       };
88248     }
88249   }
88250
88251   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88252   return jresult;
88253 }
88254
88255
88256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
88257   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88258   Dali::Actor arg2 ;
88259   Dali::Actor *argp2 ;
88260
88261   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88262   argp2 = (Dali::Actor *)jarg2;
88263   if (!argp2) {
88264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88265     return ;
88266   }
88267   arg2 = *argp2;
88268   {
88269     try {
88270       (arg1)->Add(arg2);
88271     } catch (std::out_of_range& e) {
88272       {
88273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88274       };
88275     } catch (std::exception& e) {
88276       {
88277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88278       };
88279     } catch (Dali::DaliException e) {
88280       {
88281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88282       };
88283     } catch (...) {
88284       {
88285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88286       };
88287     }
88288   }
88289
88290 }
88291
88292
88293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
88294   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88295   Dali::Actor arg2 ;
88296   Dali::Actor *argp2 ;
88297
88298   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88299   argp2 = (Dali::Actor *)jarg2;
88300   if (!argp2) {
88301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88302     return ;
88303   }
88304   arg2 = *argp2;
88305   {
88306     try {
88307       (arg1)->Remove(arg2);
88308     } catch (std::out_of_range& e) {
88309       {
88310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88311       };
88312     } catch (std::exception& e) {
88313       {
88314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88315       };
88316     } catch (Dali::DaliException e) {
88317       {
88318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88319       };
88320     } catch (...) {
88321       {
88322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88323       };
88324     }
88325   }
88326
88327 }
88328
88329
88330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
88331   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88332
88333   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88334   {
88335     try {
88336       (arg1)->Activate();
88337     } catch (std::out_of_range& e) {
88338       {
88339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88340       };
88341     } catch (std::exception& e) {
88342       {
88343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88344       };
88345     } catch (Dali::DaliException e) {
88346       {
88347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88348       };
88349     } catch (...) {
88350       {
88351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88352       };
88353     }
88354   }
88355
88356 }
88357
88358
88359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
88360   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88361
88362   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88363   {
88364     try {
88365       (arg1)->ActivateOnce();
88366     } catch (std::out_of_range& e) {
88367       {
88368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88369       };
88370     } catch (std::exception& e) {
88371       {
88372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88373       };
88374     } catch (Dali::DaliException e) {
88375       {
88376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88377       };
88378     } catch (...) {
88379       {
88380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88381       };
88382     }
88383   }
88384
88385 }
88386
88387
88388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
88389   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88390
88391   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88392   {
88393     try {
88394       (arg1)->Deactivate();
88395     } catch (std::out_of_range& e) {
88396       {
88397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88398       };
88399     } catch (std::exception& e) {
88400       {
88401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88402       };
88403     } catch (Dali::DaliException e) {
88404       {
88405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88406       };
88407     } catch (...) {
88408       {
88409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88410       };
88411     }
88412   }
88413
88414 }
88415
88416
88417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
88418   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88419   Dali::Texture arg2 ;
88420   Dali::FrameBuffer arg3 ;
88421   Dali::Texture *argp2 ;
88422   Dali::FrameBuffer *argp3 ;
88423
88424   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88425   argp2 = (Dali::Texture *)jarg2;
88426   if (!argp2) {
88427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
88428     return ;
88429   }
88430   arg2 = *argp2;
88431   argp3 = (Dali::FrameBuffer *)jarg3;
88432   if (!argp3) {
88433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
88434     return ;
88435   }
88436   arg3 = *argp3;
88437   {
88438     try {
88439       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
88440     } catch (std::out_of_range& e) {
88441       {
88442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88443       };
88444     } catch (std::exception& e) {
88445       {
88446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88447       };
88448     } catch (Dali::DaliException e) {
88449       {
88450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88451       };
88452     } catch (...) {
88453       {
88454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88455       };
88456     }
88457   }
88458
88459 }
88460
88461
88462 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
88463   int jresult ;
88464   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88465   Dali::Property::Index result;
88466
88467   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88468   {
88469     try {
88470       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
88471     } catch (std::out_of_range& e) {
88472       {
88473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88474       };
88475     } catch (std::exception& e) {
88476       {
88477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88478       };
88479     } catch (Dali::DaliException e) {
88480       {
88481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88482       };
88483     } catch (...) {
88484       {
88485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88486       };
88487     }
88488   }
88489
88490   jresult = result;
88491   return jresult;
88492 }
88493
88494
88495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
88496   void * jresult ;
88497   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88498   Dali::FrameBuffer result;
88499
88500   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88501   {
88502     try {
88503       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
88504     } catch (std::out_of_range& e) {
88505       {
88506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88507       };
88508     } catch (std::exception& e) {
88509       {
88510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88511       };
88512     } catch (Dali::DaliException e) {
88513       {
88514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88515       };
88516     } catch (...) {
88517       {
88518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88519       };
88520     }
88521   }
88522
88523   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
88524   return jresult;
88525 }
88526
88527
88528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
88529   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88530   Dali::Vector4 *arg2 = 0 ;
88531
88532   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88533   arg2 = (Dali::Vector4 *)jarg2;
88534   if (!arg2) {
88535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
88536     return ;
88537   }
88538   {
88539     try {
88540       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
88541     } catch (std::out_of_range& e) {
88542       {
88543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88544       };
88545     } catch (std::exception& e) {
88546       {
88547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88548       };
88549     } catch (Dali::DaliException e) {
88550       {
88551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88552       };
88553     } catch (...) {
88554       {
88555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88556       };
88557     }
88558   }
88559
88560 }
88561
88562
88563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
88564   void * jresult ;
88565   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88566   Dali::Vector4 result;
88567
88568   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88569   {
88570     try {
88571       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
88572     } catch (std::out_of_range& e) {
88573       {
88574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88575       };
88576     } catch (std::exception& e) {
88577       {
88578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88579       };
88580     } catch (Dali::DaliException e) {
88581       {
88582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88583       };
88584     } catch (...) {
88585       {
88586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88587       };
88588     }
88589   }
88590
88591   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
88592   return jresult;
88593 }
88594
88595
88596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
88597   void * jresult ;
88598   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88599   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
88600
88601   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88602   {
88603     try {
88604       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
88605     } catch (std::out_of_range& e) {
88606       {
88607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88608       };
88609     } catch (std::exception& e) {
88610       {
88611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88612       };
88613     } catch (Dali::DaliException e) {
88614       {
88615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88616       };
88617     } catch (...) {
88618       {
88619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88620       };
88621     }
88622   }
88623
88624   jresult = (void *)result;
88625   return jresult;
88626 }
88627
88628
88629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
88630   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
88631
88632   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
88633   {
88634     try {
88635       delete arg1;
88636     } catch (std::out_of_range& e) {
88637       {
88638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88639       };
88640     } catch (std::exception& e) {
88641       {
88642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88643       };
88644     } catch (Dali::DaliException e) {
88645       {
88646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88647       };
88648     } catch (...) {
88649       {
88650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88651       };
88652     }
88653   }
88654
88655 }
88656
88657
88658 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
88659   unsigned int jresult ;
88660   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
88661   unsigned int result;
88662
88663   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
88664   {
88665     try {
88666       result = (unsigned int)(arg1)->GetNumberOfPages();
88667     } catch (std::out_of_range& e) {
88668       {
88669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88670       };
88671     } catch (std::exception& e) {
88672       {
88673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88674       };
88675     } catch (Dali::DaliException e) {
88676       {
88677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88678       };
88679     } catch (...) {
88680       {
88681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88682       };
88683     }
88684   }
88685
88686   jresult = result;
88687   return jresult;
88688 }
88689
88690
88691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
88692   void * jresult ;
88693   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
88694   unsigned int arg2 ;
88695   Dali::Texture result;
88696
88697   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
88698   arg2 = (unsigned int)jarg2;
88699   {
88700     try {
88701       result = (arg1)->NewPage(arg2);
88702     } catch (std::out_of_range& e) {
88703       {
88704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88705       };
88706     } catch (std::exception& e) {
88707       {
88708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88709       };
88710     } catch (Dali::DaliException e) {
88711       {
88712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88713       };
88714     } catch (...) {
88715       {
88716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88717       };
88718     }
88719   }
88720
88721   jresult = new Dali::Texture((const Dali::Texture &)result);
88722   return jresult;
88723 }
88724
88725
88726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
88727   int jresult ;
88728   int result;
88729
88730   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
88731   jresult = (int)result;
88732   return jresult;
88733 }
88734
88735
88736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
88737   int jresult ;
88738   int result;
88739
88740   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
88741   jresult = (int)result;
88742   return jresult;
88743 }
88744
88745
88746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
88747   int jresult ;
88748   int result;
88749
88750   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
88751   jresult = (int)result;
88752   return jresult;
88753 }
88754
88755
88756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
88757   void * jresult ;
88758   Dali::Toolkit::PageTurnView::Property *result = 0 ;
88759
88760   {
88761     try {
88762       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
88763     } catch (std::out_of_range& e) {
88764       {
88765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88766       };
88767     } catch (std::exception& e) {
88768       {
88769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88770       };
88771     } catch (Dali::DaliException e) {
88772       {
88773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88774       };
88775     } catch (...) {
88776       {
88777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88778       };
88779     }
88780   }
88781
88782   jresult = (void *)result;
88783   return jresult;
88784 }
88785
88786
88787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
88788   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
88789
88790   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
88791   {
88792     try {
88793       delete arg1;
88794     } catch (std::out_of_range& e) {
88795       {
88796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88797       };
88798     } catch (std::exception& e) {
88799       {
88800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88801       };
88802     } catch (Dali::DaliException e) {
88803       {
88804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88805       };
88806     } catch (...) {
88807       {
88808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88809       };
88810     }
88811   }
88812
88813 }
88814
88815
88816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
88817   void * jresult ;
88818   Dali::Toolkit::PageTurnView *result = 0 ;
88819
88820   {
88821     try {
88822       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
88823     } catch (std::out_of_range& e) {
88824       {
88825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88826       };
88827     } catch (std::exception& e) {
88828       {
88829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88830       };
88831     } catch (Dali::DaliException e) {
88832       {
88833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88834       };
88835     } catch (...) {
88836       {
88837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88838       };
88839     }
88840   }
88841
88842   jresult = (void *)result;
88843   return jresult;
88844 }
88845
88846
88847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
88848   void * jresult ;
88849   Dali::Toolkit::PageTurnView *arg1 = 0 ;
88850   Dali::Toolkit::PageTurnView *result = 0 ;
88851
88852   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88853   if (!arg1) {
88854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
88855     return 0;
88856   }
88857   {
88858     try {
88859       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
88860     } catch (std::out_of_range& e) {
88861       {
88862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88863       };
88864     } catch (std::exception& e) {
88865       {
88866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88867       };
88868     } catch (Dali::DaliException e) {
88869       {
88870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88871       };
88872     } catch (...) {
88873       {
88874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88875       };
88876     }
88877   }
88878
88879   jresult = (void *)result;
88880   return jresult;
88881 }
88882
88883
88884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
88885   void * jresult ;
88886   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88887   Dali::Toolkit::PageTurnView *arg2 = 0 ;
88888   Dali::Toolkit::PageTurnView *result = 0 ;
88889
88890   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88891   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
88892   if (!arg2) {
88893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
88894     return 0;
88895   }
88896   {
88897     try {
88898       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
88899     } catch (std::out_of_range& e) {
88900       {
88901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88902       };
88903     } catch (std::exception& e) {
88904       {
88905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88906       };
88907     } catch (Dali::DaliException e) {
88908       {
88909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88910       };
88911     } catch (...) {
88912       {
88913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88914       };
88915     }
88916   }
88917
88918   jresult = (void *)result;
88919   return jresult;
88920 }
88921
88922
88923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
88924   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88925
88926   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88927   {
88928     try {
88929       delete arg1;
88930     } catch (std::out_of_range& e) {
88931       {
88932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88933       };
88934     } catch (std::exception& e) {
88935       {
88936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88937       };
88938     } catch (Dali::DaliException e) {
88939       {
88940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88941       };
88942     } catch (...) {
88943       {
88944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88945       };
88946     }
88947   }
88948
88949 }
88950
88951
88952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
88953   void * jresult ;
88954   Dali::BaseHandle arg1 ;
88955   Dali::BaseHandle *argp1 ;
88956   Dali::Toolkit::PageTurnView result;
88957
88958   argp1 = (Dali::BaseHandle *)jarg1;
88959   if (!argp1) {
88960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88961     return 0;
88962   }
88963   arg1 = *argp1;
88964   {
88965     try {
88966       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
88967     } catch (std::out_of_range& e) {
88968       {
88969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88970       };
88971     } catch (std::exception& e) {
88972       {
88973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88974       };
88975     } catch (Dali::DaliException e) {
88976       {
88977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88978       };
88979     } catch (...) {
88980       {
88981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88982       };
88983     }
88984   }
88985
88986   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
88987   return jresult;
88988 }
88989
88990
88991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
88992   void * jresult ;
88993   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88994   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
88995
88996   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88997   {
88998     try {
88999       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
89000     } catch (std::out_of_range& e) {
89001       {
89002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89003       };
89004     } catch (std::exception& e) {
89005       {
89006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89007       };
89008     } catch (Dali::DaliException e) {
89009       {
89010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89011       };
89012     } catch (...) {
89013       {
89014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89015       };
89016     }
89017   }
89018
89019   jresult = (void *)result;
89020   return jresult;
89021 }
89022
89023
89024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
89025   void * jresult ;
89026   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89027   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
89028
89029   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89030   {
89031     try {
89032       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
89033     } catch (std::out_of_range& e) {
89034       {
89035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89036       };
89037     } catch (std::exception& e) {
89038       {
89039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89040       };
89041     } catch (Dali::DaliException e) {
89042       {
89043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89044       };
89045     } catch (...) {
89046       {
89047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89048       };
89049     }
89050   }
89051
89052   jresult = (void *)result;
89053   return jresult;
89054 }
89055
89056
89057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
89058   void * jresult ;
89059   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89060   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
89061
89062   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89063   {
89064     try {
89065       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
89066     } catch (std::out_of_range& e) {
89067       {
89068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89069       };
89070     } catch (std::exception& e) {
89071       {
89072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89073       };
89074     } catch (Dali::DaliException e) {
89075       {
89076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89077       };
89078     } catch (...) {
89079       {
89080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89081       };
89082     }
89083   }
89084
89085   jresult = (void *)result;
89086   return jresult;
89087 }
89088
89089
89090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
89091   void * jresult ;
89092   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89093   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
89094
89095   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89096   {
89097     try {
89098       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
89099     } catch (std::out_of_range& e) {
89100       {
89101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89102       };
89103     } catch (std::exception& e) {
89104       {
89105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89106       };
89107     } catch (Dali::DaliException e) {
89108       {
89109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89110       };
89111     } catch (...) {
89112       {
89113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89114       };
89115     }
89116   }
89117
89118   jresult = (void *)result;
89119   return jresult;
89120 }
89121
89122
89123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
89124   void * jresult ;
89125   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89126
89127   {
89128     try {
89129       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
89130     } catch (std::out_of_range& e) {
89131       {
89132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89133       };
89134     } catch (std::exception& e) {
89135       {
89136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89137       };
89138     } catch (Dali::DaliException e) {
89139       {
89140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89141       };
89142     } catch (...) {
89143       {
89144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89145       };
89146     }
89147   }
89148
89149   jresult = (void *)result;
89150   return jresult;
89151 }
89152
89153
89154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
89155   void * jresult ;
89156   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
89157   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89158
89159   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89160   if (!arg1) {
89161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
89162     return 0;
89163   }
89164   {
89165     try {
89166       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
89167     } catch (std::out_of_range& e) {
89168       {
89169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89170       };
89171     } catch (std::exception& e) {
89172       {
89173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89174       };
89175     } catch (Dali::DaliException e) {
89176       {
89177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89178       };
89179     } catch (...) {
89180       {
89181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89182       };
89183     }
89184   }
89185
89186   jresult = (void *)result;
89187   return jresult;
89188 }
89189
89190
89191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
89192   void * jresult ;
89193   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
89194   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
89195   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89196
89197   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89198   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
89199   if (!arg2) {
89200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
89201     return 0;
89202   }
89203   {
89204     try {
89205       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
89206     } catch (std::out_of_range& e) {
89207       {
89208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89209       };
89210     } catch (std::exception& e) {
89211       {
89212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89213       };
89214     } catch (Dali::DaliException e) {
89215       {
89216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89217       };
89218     } catch (...) {
89219       {
89220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89221       };
89222     }
89223   }
89224
89225   jresult = (void *)result;
89226   return jresult;
89227 }
89228
89229
89230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
89231   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
89232
89233   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89234   {
89235     try {
89236       delete arg1;
89237     } catch (std::out_of_range& e) {
89238       {
89239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89240       };
89241     } catch (std::exception& e) {
89242       {
89243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89244       };
89245     } catch (Dali::DaliException e) {
89246       {
89247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89248       };
89249     } catch (...) {
89250       {
89251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89252       };
89253     }
89254   }
89255
89256 }
89257
89258
89259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
89260   void * jresult ;
89261   Dali::Toolkit::PageFactory *arg1 = 0 ;
89262   Dali::Vector2 *arg2 = 0 ;
89263   Dali::Toolkit::PageTurnLandscapeView result;
89264
89265   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89266   if (!arg1) {
89267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
89268     return 0;
89269   }
89270   arg2 = (Dali::Vector2 *)jarg2;
89271   if (!arg2) {
89272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
89273     return 0;
89274   }
89275   {
89276     try {
89277       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
89278     } catch (std::out_of_range& e) {
89279       {
89280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89281       };
89282     } catch (std::exception& e) {
89283       {
89284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89285       };
89286     } catch (Dali::DaliException e) {
89287       {
89288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89289       };
89290     } catch (...) {
89291       {
89292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89293       };
89294     }
89295   }
89296
89297   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
89298   return jresult;
89299 }
89300
89301
89302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
89303   void * jresult ;
89304   Dali::BaseHandle arg1 ;
89305   Dali::BaseHandle *argp1 ;
89306   Dali::Toolkit::PageTurnLandscapeView result;
89307
89308   argp1 = (Dali::BaseHandle *)jarg1;
89309   if (!argp1) {
89310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89311     return 0;
89312   }
89313   arg1 = *argp1;
89314   {
89315     try {
89316       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
89317     } catch (std::out_of_range& e) {
89318       {
89319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89320       };
89321     } catch (std::exception& e) {
89322       {
89323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89324       };
89325     } catch (Dali::DaliException e) {
89326       {
89327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89328       };
89329     } catch (...) {
89330       {
89331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89332       };
89333     }
89334   }
89335
89336   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
89337   return jresult;
89338 }
89339
89340
89341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
89342   void * jresult ;
89343   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
89344
89345   {
89346     try {
89347       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
89348     } catch (std::out_of_range& e) {
89349       {
89350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89351       };
89352     } catch (std::exception& e) {
89353       {
89354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89355       };
89356     } catch (Dali::DaliException e) {
89357       {
89358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89359       };
89360     } catch (...) {
89361       {
89362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89363       };
89364     }
89365   }
89366
89367   jresult = (void *)result;
89368   return jresult;
89369 }
89370
89371
89372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
89373   void * jresult ;
89374   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
89375   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
89376
89377   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
89378   if (!arg1) {
89379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
89380     return 0;
89381   }
89382   {
89383     try {
89384       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
89385     } catch (std::out_of_range& e) {
89386       {
89387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89388       };
89389     } catch (std::exception& e) {
89390       {
89391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89392       };
89393     } catch (Dali::DaliException e) {
89394       {
89395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89396       };
89397     } catch (...) {
89398       {
89399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89400       };
89401     }
89402   }
89403
89404   jresult = (void *)result;
89405   return jresult;
89406 }
89407
89408
89409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
89410   void * jresult ;
89411   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
89412   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
89413   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
89414
89415   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
89416   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
89417   if (!arg2) {
89418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
89419     return 0;
89420   }
89421   {
89422     try {
89423       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
89424     } catch (std::out_of_range& e) {
89425       {
89426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89427       };
89428     } catch (std::exception& e) {
89429       {
89430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89431       };
89432     } catch (Dali::DaliException e) {
89433       {
89434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89435       };
89436     } catch (...) {
89437       {
89438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89439       };
89440     }
89441   }
89442
89443   jresult = (void *)result;
89444   return jresult;
89445 }
89446
89447
89448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
89449   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
89450
89451   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
89452   {
89453     try {
89454       delete arg1;
89455     } catch (std::out_of_range& e) {
89456       {
89457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89458       };
89459     } catch (std::exception& e) {
89460       {
89461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89462       };
89463     } catch (Dali::DaliException e) {
89464       {
89465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89466       };
89467     } catch (...) {
89468       {
89469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89470       };
89471     }
89472   }
89473
89474 }
89475
89476
89477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
89478   void * jresult ;
89479   Dali::Toolkit::PageFactory *arg1 = 0 ;
89480   Dali::Vector2 *arg2 = 0 ;
89481   Dali::Toolkit::PageTurnPortraitView result;
89482
89483   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89484   if (!arg1) {
89485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
89486     return 0;
89487   }
89488   arg2 = (Dali::Vector2 *)jarg2;
89489   if (!arg2) {
89490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
89491     return 0;
89492   }
89493   {
89494     try {
89495       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
89496     } catch (std::out_of_range& e) {
89497       {
89498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89499       };
89500     } catch (std::exception& e) {
89501       {
89502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89503       };
89504     } catch (Dali::DaliException e) {
89505       {
89506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89507       };
89508     } catch (...) {
89509       {
89510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89511       };
89512     }
89513   }
89514
89515   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
89516   return jresult;
89517 }
89518
89519
89520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
89521   void * jresult ;
89522   Dali::BaseHandle arg1 ;
89523   Dali::BaseHandle *argp1 ;
89524   Dali::Toolkit::PageTurnPortraitView result;
89525
89526   argp1 = (Dali::BaseHandle *)jarg1;
89527   if (!argp1) {
89528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89529     return 0;
89530   }
89531   arg1 = *argp1;
89532   {
89533     try {
89534       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
89535     } catch (std::out_of_range& e) {
89536       {
89537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89538       };
89539     } catch (std::exception& e) {
89540       {
89541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89542       };
89543     } catch (Dali::DaliException e) {
89544       {
89545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89546       };
89547     } catch (...) {
89548       {
89549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89550       };
89551     }
89552   }
89553
89554   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
89555   return jresult;
89556 }
89557
89558
89559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
89560   int jresult ;
89561   int result;
89562
89563   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
89564   jresult = (int)result;
89565   return jresult;
89566 }
89567
89568
89569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
89570   int jresult ;
89571   int result;
89572
89573   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
89574   jresult = (int)result;
89575   return jresult;
89576 }
89577
89578
89579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
89580   int jresult ;
89581   int result;
89582
89583   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
89584   jresult = (int)result;
89585   return jresult;
89586 }
89587
89588
89589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
89590   void * jresult ;
89591   Dali::Toolkit::ToggleButton::Property *result = 0 ;
89592
89593   {
89594     try {
89595       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
89596     } catch (std::out_of_range& e) {
89597       {
89598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89599       };
89600     } catch (std::exception& e) {
89601       {
89602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89603       };
89604     } catch (Dali::DaliException e) {
89605       {
89606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89607       };
89608     } catch (...) {
89609       {
89610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89611       };
89612     }
89613   }
89614
89615   jresult = (void *)result;
89616   return jresult;
89617 }
89618
89619
89620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
89621   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
89622
89623   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
89624   {
89625     try {
89626       delete arg1;
89627     } catch (std::out_of_range& e) {
89628       {
89629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89630       };
89631     } catch (std::exception& e) {
89632       {
89633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89634       };
89635     } catch (Dali::DaliException e) {
89636       {
89637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89638       };
89639     } catch (...) {
89640       {
89641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89642       };
89643     }
89644   }
89645
89646 }
89647
89648
89649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
89650   void * jresult ;
89651   Dali::Toolkit::ToggleButton *result = 0 ;
89652
89653   {
89654     try {
89655       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
89656     } catch (std::out_of_range& e) {
89657       {
89658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89659       };
89660     } catch (std::exception& e) {
89661       {
89662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89663       };
89664     } catch (Dali::DaliException e) {
89665       {
89666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89667       };
89668     } catch (...) {
89669       {
89670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89671       };
89672     }
89673   }
89674
89675   jresult = (void *)result;
89676   return jresult;
89677 }
89678
89679
89680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
89681   void * jresult ;
89682   Dali::Toolkit::ToggleButton *arg1 = 0 ;
89683   Dali::Toolkit::ToggleButton *result = 0 ;
89684
89685   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
89686   if (!arg1) {
89687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
89688     return 0;
89689   }
89690   {
89691     try {
89692       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
89693     } catch (std::out_of_range& e) {
89694       {
89695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89696       };
89697     } catch (std::exception& e) {
89698       {
89699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89700       };
89701     } catch (Dali::DaliException e) {
89702       {
89703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89704       };
89705     } catch (...) {
89706       {
89707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89708       };
89709     }
89710   }
89711
89712   jresult = (void *)result;
89713   return jresult;
89714 }
89715
89716
89717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
89718   void * jresult ;
89719   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
89720   Dali::Toolkit::ToggleButton *arg2 = 0 ;
89721   Dali::Toolkit::ToggleButton *result = 0 ;
89722
89723   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
89724   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
89725   if (!arg2) {
89726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
89727     return 0;
89728   }
89729   {
89730     try {
89731       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
89732     } catch (std::out_of_range& e) {
89733       {
89734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89735       };
89736     } catch (std::exception& e) {
89737       {
89738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89739       };
89740     } catch (Dali::DaliException e) {
89741       {
89742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89743       };
89744     } catch (...) {
89745       {
89746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89747       };
89748     }
89749   }
89750
89751   jresult = (void *)result;
89752   return jresult;
89753 }
89754
89755
89756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
89757   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
89758
89759   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
89760   {
89761     try {
89762       delete arg1;
89763     } catch (std::out_of_range& e) {
89764       {
89765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89766       };
89767     } catch (std::exception& e) {
89768       {
89769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89770       };
89771     } catch (Dali::DaliException e) {
89772       {
89773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89774       };
89775     } catch (...) {
89776       {
89777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89778       };
89779     }
89780   }
89781
89782 }
89783
89784
89785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
89786   void * jresult ;
89787   Dali::Toolkit::ToggleButton result;
89788
89789   {
89790     try {
89791       result = Dali::Toolkit::ToggleButton::New();
89792     } catch (std::out_of_range& e) {
89793       {
89794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89795       };
89796     } catch (std::exception& e) {
89797       {
89798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89799       };
89800     } catch (Dali::DaliException e) {
89801       {
89802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89803       };
89804     } catch (...) {
89805       {
89806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89807       };
89808     }
89809   }
89810
89811   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
89812   return jresult;
89813 }
89814
89815
89816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
89817   void * jresult ;
89818   Dali::BaseHandle arg1 ;
89819   Dali::BaseHandle *argp1 ;
89820   Dali::Toolkit::ToggleButton result;
89821
89822   argp1 = (Dali::BaseHandle *)jarg1;
89823   if (!argp1) {
89824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89825     return 0;
89826   }
89827   arg1 = *argp1;
89828   {
89829     try {
89830       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
89831     } catch (std::out_of_range& e) {
89832       {
89833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89834       };
89835     } catch (std::exception& e) {
89836       {
89837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89838       };
89839     } catch (Dali::DaliException e) {
89840       {
89841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89842       };
89843     } catch (...) {
89844       {
89845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89846       };
89847     }
89848   }
89849
89850   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
89851   return jresult;
89852 }
89853
89854
89855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
89856   void * jresult ;
89857   Dali::Toolkit::Visual::Base *result = 0 ;
89858
89859   {
89860     try {
89861       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
89862     } catch (std::out_of_range& e) {
89863       {
89864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89865       };
89866     } catch (std::exception& e) {
89867       {
89868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89869       };
89870     } catch (Dali::DaliException e) {
89871       {
89872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89873       };
89874     } catch (...) {
89875       {
89876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89877       };
89878     }
89879   }
89880
89881   jresult = (void *)result;
89882   return jresult;
89883 }
89884
89885
89886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
89887   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89888
89889   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89890   {
89891     try {
89892       delete arg1;
89893     } catch (std::out_of_range& e) {
89894       {
89895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89896       };
89897     } catch (std::exception& e) {
89898       {
89899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89900       };
89901     } catch (Dali::DaliException e) {
89902       {
89903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89904       };
89905     } catch (...) {
89906       {
89907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89908       };
89909     }
89910   }
89911
89912 }
89913
89914
89915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
89916   void * jresult ;
89917   Dali::Toolkit::Visual::Base *arg1 = 0 ;
89918   Dali::Toolkit::Visual::Base *result = 0 ;
89919
89920   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89921   if (!arg1) {
89922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
89923     return 0;
89924   }
89925   {
89926     try {
89927       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
89928     } catch (std::out_of_range& e) {
89929       {
89930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89931       };
89932     } catch (std::exception& e) {
89933       {
89934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89935       };
89936     } catch (Dali::DaliException e) {
89937       {
89938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89939       };
89940     } catch (...) {
89941       {
89942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89943       };
89944     }
89945   }
89946
89947   jresult = (void *)result;
89948   return jresult;
89949 }
89950
89951
89952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
89953   void * jresult ;
89954   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89955   Dali::Toolkit::Visual::Base *arg2 = 0 ;
89956   Dali::Toolkit::Visual::Base *result = 0 ;
89957
89958   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89959   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
89960   if (!arg2) {
89961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
89962     return 0;
89963   }
89964   {
89965     try {
89966       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
89967     } catch (std::out_of_range& e) {
89968       {
89969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89970       };
89971     } catch (std::exception& e) {
89972       {
89973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89974       };
89975     } catch (Dali::DaliException e) {
89976       {
89977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89978       };
89979     } catch (...) {
89980       {
89981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89982       };
89983     }
89984   }
89985
89986   jresult = (void *)result;
89987   return jresult;
89988 }
89989
89990
89991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
89992   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89993   std::string *arg2 = 0 ;
89994
89995   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89996   if (!jarg2) {
89997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
89998     return ;
89999   }
90000   std::string arg2_str(jarg2);
90001   arg2 = &arg2_str;
90002   {
90003     try {
90004       (arg1)->SetName((std::string const &)*arg2);
90005     } catch (std::out_of_range& e) {
90006       {
90007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90008       };
90009     } catch (std::exception& e) {
90010       {
90011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90012       };
90013     } catch (Dali::DaliException e) {
90014       {
90015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90016       };
90017     } catch (...) {
90018       {
90019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90020       };
90021     }
90022   }
90023
90024
90025   //argout typemap for const std::string&
90026
90027 }
90028
90029
90030 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
90031   char * jresult ;
90032   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90033   std::string *result = 0 ;
90034
90035   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90036   {
90037     try {
90038       result = (std::string *) &(arg1)->GetName();
90039     } catch (std::out_of_range& e) {
90040       {
90041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90042       };
90043     } catch (std::exception& e) {
90044       {
90045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90046       };
90047     } catch (Dali::DaliException e) {
90048       {
90049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90050       };
90051     } catch (...) {
90052       {
90053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90054       };
90055     }
90056   }
90057
90058   jresult = SWIG_csharp_string_callback(result->c_str());
90059   return jresult;
90060 }
90061
90062
90063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
90064   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90065   Dali::Property::Map *arg2 = 0 ;
90066   Dali::Size arg3 ;
90067   Dali::Size *argp3 ;
90068
90069   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90070   arg2 = (Dali::Property::Map *)jarg2;
90071   if (!arg2) {
90072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
90073     return ;
90074   }
90075   argp3 = (Dali::Size *)jarg3;
90076   if (!argp3) {
90077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
90078     return ;
90079   }
90080   arg3 = *argp3;
90081   {
90082     try {
90083       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
90084     } catch (std::out_of_range& e) {
90085       {
90086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90087       };
90088     } catch (std::exception& e) {
90089       {
90090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90091       };
90092     } catch (Dali::DaliException e) {
90093       {
90094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90095       };
90096     } catch (...) {
90097       {
90098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90099       };
90100     }
90101   }
90102
90103 }
90104
90105
90106 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
90107   float jresult ;
90108   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90109   float arg2 ;
90110   float result;
90111
90112   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90113   arg2 = (float)jarg2;
90114   {
90115     try {
90116       result = (float)(arg1)->GetHeightForWidth(arg2);
90117     } catch (std::out_of_range& e) {
90118       {
90119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90120       };
90121     } catch (std::exception& e) {
90122       {
90123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90124       };
90125     } catch (Dali::DaliException e) {
90126       {
90127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90128       };
90129     } catch (...) {
90130       {
90131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90132       };
90133     }
90134   }
90135
90136   jresult = result;
90137   return jresult;
90138 }
90139
90140
90141 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
90142   float jresult ;
90143   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90144   float arg2 ;
90145   float result;
90146
90147   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90148   arg2 = (float)jarg2;
90149   {
90150     try {
90151       result = (float)(arg1)->GetWidthForHeight(arg2);
90152     } catch (std::out_of_range& e) {
90153       {
90154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90155       };
90156     } catch (std::exception& e) {
90157       {
90158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90159       };
90160     } catch (Dali::DaliException e) {
90161       {
90162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90163       };
90164     } catch (...) {
90165       {
90166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90167       };
90168     }
90169   }
90170
90171   jresult = result;
90172   return jresult;
90173 }
90174
90175
90176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
90177   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90178   Dali::Vector2 *arg2 = 0 ;
90179
90180   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90181   arg2 = (Dali::Vector2 *)jarg2;
90182   if (!arg2) {
90183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
90184     return ;
90185   }
90186   {
90187     try {
90188       (arg1)->GetNaturalSize(*arg2);
90189     } catch (std::out_of_range& e) {
90190       {
90191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90192       };
90193     } catch (std::exception& e) {
90194       {
90195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90196       };
90197     } catch (Dali::DaliException e) {
90198       {
90199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90200       };
90201     } catch (...) {
90202       {
90203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90204       };
90205     }
90206   }
90207
90208 }
90209
90210
90211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
90212   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90213   float arg2 ;
90214
90215   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90216   arg2 = (int)jarg2;
90217   {
90218     try {
90219       (arg1)->SetDepthIndex(arg2);
90220     } catch (std::out_of_range& e) {
90221       {
90222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90223       };
90224     } catch (std::exception& e) {
90225       {
90226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90227       };
90228     } catch (Dali::DaliException e) {
90229       {
90230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90231       };
90232     } catch (...) {
90233       {
90234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90235       };
90236     }
90237   }
90238
90239 }
90240
90241
90242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
90243   int jresult ;
90244   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90245   int result;
90246
90247   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90248   {
90249     try {
90250       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
90251     } catch (std::out_of_range& e) {
90252       {
90253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90254       };
90255     } catch (std::exception& e) {
90256       {
90257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90258       };
90259     } catch (Dali::DaliException e) {
90260       {
90261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90262       };
90263     } catch (...) {
90264       {
90265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90266       };
90267     }
90268   }
90269
90270   jresult = result;
90271   return jresult;
90272 }
90273
90274
90275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
90276   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90277   Dali::Property::Map *arg2 = 0 ;
90278
90279   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90280   arg2 = (Dali::Property::Map *)jarg2;
90281   if (!arg2) {
90282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
90283     return ;
90284   }
90285   {
90286     try {
90287       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
90288     } catch (std::out_of_range& e) {
90289       {
90290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90291       };
90292     } catch (std::exception& e) {
90293       {
90294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90295       };
90296     } catch (Dali::DaliException e) {
90297       {
90298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90299       };
90300     } catch (...) {
90301       {
90302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90303       };
90304     }
90305   }
90306
90307 }
90308
90309
90310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
90311   void * jresult ;
90312   Dali::Toolkit::VisualFactory result;
90313
90314   {
90315     try {
90316       result = Dali::Toolkit::VisualFactory::Get();
90317     } catch (std::out_of_range& e) {
90318       {
90319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90320       };
90321     } catch (std::exception& e) {
90322       {
90323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90324       };
90325     } catch (Dali::DaliException e) {
90326       {
90327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90328       };
90329     } catch (...) {
90330       {
90331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90332       };
90333     }
90334   }
90335
90336   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
90337   return jresult;
90338 }
90339
90340
90341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
90342   void * jresult ;
90343   Dali::Toolkit::VisualFactory *result = 0 ;
90344
90345   {
90346     try {
90347       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
90348     } catch (std::out_of_range& e) {
90349       {
90350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90351       };
90352     } catch (std::exception& e) {
90353       {
90354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90355       };
90356     } catch (Dali::DaliException e) {
90357       {
90358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90359       };
90360     } catch (...) {
90361       {
90362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90363       };
90364     }
90365   }
90366
90367   jresult = (void *)result;
90368   return jresult;
90369 }
90370
90371
90372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
90373   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90374
90375   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90376   {
90377     try {
90378       delete arg1;
90379     } catch (std::out_of_range& e) {
90380       {
90381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90382       };
90383     } catch (std::exception& e) {
90384       {
90385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90386       };
90387     } catch (Dali::DaliException e) {
90388       {
90389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90390       };
90391     } catch (...) {
90392       {
90393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90394       };
90395     }
90396   }
90397
90398 }
90399
90400
90401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
90402   void * jresult ;
90403   Dali::Toolkit::VisualFactory *arg1 = 0 ;
90404   Dali::Toolkit::VisualFactory *result = 0 ;
90405
90406   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90407   if (!arg1) {
90408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
90409     return 0;
90410   }
90411   {
90412     try {
90413       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
90414     } catch (std::out_of_range& e) {
90415       {
90416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90417       };
90418     } catch (std::exception& e) {
90419       {
90420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90421       };
90422     } catch (Dali::DaliException e) {
90423       {
90424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90425       };
90426     } catch (...) {
90427       {
90428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90429       };
90430     }
90431   }
90432
90433   jresult = (void *)result;
90434   return jresult;
90435 }
90436
90437
90438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
90439   void * jresult ;
90440   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90441   Dali::Toolkit::VisualFactory *arg2 = 0 ;
90442   Dali::Toolkit::VisualFactory *result = 0 ;
90443
90444   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90445   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
90446   if (!arg2) {
90447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
90448     return 0;
90449   }
90450   {
90451     try {
90452       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
90453     } catch (std::out_of_range& e) {
90454       {
90455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90456       };
90457     } catch (std::exception& e) {
90458       {
90459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90460       };
90461     } catch (Dali::DaliException e) {
90462       {
90463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90464       };
90465     } catch (...) {
90466       {
90467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90468       };
90469     }
90470   }
90471
90472   jresult = (void *)result;
90473   return jresult;
90474 }
90475
90476
90477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
90478   void * jresult ;
90479   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90480   Dali::Property::Map *arg2 = 0 ;
90481   Dali::Toolkit::Visual::Base result;
90482
90483   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90484   arg2 = (Dali::Property::Map *)jarg2;
90485   if (!arg2) {
90486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
90487     return 0;
90488   }
90489   {
90490     try {
90491       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
90492     } catch (std::out_of_range& e) {
90493       {
90494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90495       };
90496     } catch (std::exception& e) {
90497       {
90498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90499       };
90500     } catch (Dali::DaliException e) {
90501       {
90502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90503       };
90504     } catch (...) {
90505       {
90506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90507       };
90508     }
90509   }
90510
90511   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
90512   return jresult;
90513 }
90514
90515
90516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
90517   void * jresult ;
90518   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90519   Dali::Image *arg2 = 0 ;
90520   Dali::Toolkit::Visual::Base result;
90521
90522   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90523   arg2 = (Dali::Image *)jarg2;
90524   if (!arg2) {
90525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
90526     return 0;
90527   }
90528   {
90529     try {
90530       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
90531     } catch (std::out_of_range& e) {
90532       {
90533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90534       };
90535     } catch (std::exception& e) {
90536       {
90537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90538       };
90539     } catch (Dali::DaliException e) {
90540       {
90541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90542       };
90543     } catch (...) {
90544       {
90545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90546       };
90547     }
90548   }
90549
90550   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
90551   return jresult;
90552 }
90553
90554
90555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
90556   void * jresult ;
90557   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90558   std::string *arg2 = 0 ;
90559   Dali::ImageDimensions arg3 ;
90560   Dali::ImageDimensions *argp3 ;
90561   Dali::Toolkit::Visual::Base result;
90562
90563   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90564   if (!jarg2) {
90565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90566     return 0;
90567   }
90568   std::string arg2_str(jarg2);
90569   arg2 = &arg2_str;
90570   argp3 = (Dali::ImageDimensions *)jarg3;
90571   if (!argp3) {
90572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
90573     return 0;
90574   }
90575   arg3 = *argp3;
90576   {
90577     try {
90578       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
90579     } catch (std::out_of_range& e) {
90580       {
90581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90582       };
90583     } catch (std::exception& e) {
90584       {
90585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90586       };
90587     } catch (Dali::DaliException e) {
90588       {
90589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90590       };
90591     } catch (...) {
90592       {
90593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90594       };
90595     }
90596   }
90597
90598   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
90599
90600   //argout typemap for const std::string&
90601
90602   return jresult;
90603 }
90604
90605
90606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
90607   void * jresult ;
90608   Dali::Toolkit::AsyncImageLoader *result = 0 ;
90609
90610   {
90611     try {
90612       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
90613     } catch (std::out_of_range& e) {
90614       {
90615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90616       };
90617     } catch (std::exception& e) {
90618       {
90619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90620       };
90621     } catch (Dali::DaliException e) {
90622       {
90623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90624       };
90625     } catch (...) {
90626       {
90627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90628       };
90629     }
90630   }
90631
90632   jresult = (void *)result;
90633   return jresult;
90634 }
90635
90636
90637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
90638   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90639
90640   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90641   {
90642     try {
90643       delete arg1;
90644     } catch (std::out_of_range& e) {
90645       {
90646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90647       };
90648     } catch (std::exception& e) {
90649       {
90650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90651       };
90652     } catch (Dali::DaliException e) {
90653       {
90654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90655       };
90656     } catch (...) {
90657       {
90658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90659       };
90660     }
90661   }
90662
90663 }
90664
90665
90666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
90667   void * jresult ;
90668   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
90669   Dali::Toolkit::AsyncImageLoader *result = 0 ;
90670
90671   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90672   if (!arg1) {
90673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
90674     return 0;
90675   }
90676   {
90677     try {
90678       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
90679     } catch (std::out_of_range& e) {
90680       {
90681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90682       };
90683     } catch (std::exception& e) {
90684       {
90685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90686       };
90687     } catch (Dali::DaliException e) {
90688       {
90689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90690       };
90691     } catch (...) {
90692       {
90693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90694       };
90695     }
90696   }
90697
90698   jresult = (void *)result;
90699   return jresult;
90700 }
90701
90702
90703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
90704   void * jresult ;
90705   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90706   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
90707   Dali::Toolkit::AsyncImageLoader *result = 0 ;
90708
90709   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90710   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
90711   if (!arg2) {
90712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
90713     return 0;
90714   }
90715   {
90716     try {
90717       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
90718     } catch (std::out_of_range& e) {
90719       {
90720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90721       };
90722     } catch (std::exception& e) {
90723       {
90724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90725       };
90726     } catch (Dali::DaliException e) {
90727       {
90728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90729       };
90730     } catch (...) {
90731       {
90732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90733       };
90734     }
90735   }
90736
90737   jresult = (void *)result;
90738   return jresult;
90739 }
90740
90741
90742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
90743   void * jresult ;
90744   Dali::Toolkit::AsyncImageLoader result;
90745
90746   {
90747     try {
90748       result = Dali::Toolkit::AsyncImageLoader::New();
90749     } catch (std::out_of_range& e) {
90750       {
90751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90752       };
90753     } catch (std::exception& e) {
90754       {
90755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90756       };
90757     } catch (Dali::DaliException e) {
90758       {
90759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90760       };
90761     } catch (...) {
90762       {
90763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90764       };
90765     }
90766   }
90767
90768   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
90769   return jresult;
90770 }
90771
90772
90773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
90774   void * jresult ;
90775   Dali::BaseHandle arg1 ;
90776   Dali::BaseHandle *argp1 ;
90777   Dali::Toolkit::AsyncImageLoader result;
90778
90779   argp1 = (Dali::BaseHandle *)jarg1;
90780   if (!argp1) {
90781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90782     return 0;
90783   }
90784   arg1 = *argp1;
90785   {
90786     try {
90787       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
90788     } catch (std::out_of_range& e) {
90789       {
90790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90791       };
90792     } catch (std::exception& e) {
90793       {
90794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90795       };
90796     } catch (Dali::DaliException e) {
90797       {
90798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90799       };
90800     } catch (...) {
90801       {
90802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90803       };
90804     }
90805   }
90806
90807   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
90808   return jresult;
90809 }
90810
90811
90812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
90813   unsigned int jresult ;
90814   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90815   std::string *arg2 = 0 ;
90816   uint32_t result;
90817
90818   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90819   if (!jarg2) {
90820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90821     return 0;
90822   }
90823   std::string arg2_str(jarg2);
90824   arg2 = &arg2_str;
90825   {
90826     try {
90827       result = (arg1)->Load((std::string const &)*arg2);
90828     } catch (std::out_of_range& e) {
90829       {
90830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90831       };
90832     } catch (std::exception& e) {
90833       {
90834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90835       };
90836     } catch (Dali::DaliException e) {
90837       {
90838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90839       };
90840     } catch (...) {
90841       {
90842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90843       };
90844     }
90845   }
90846
90847   jresult = result;
90848
90849   //argout typemap for const std::string&
90850
90851   return jresult;
90852 }
90853
90854
90855 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
90856   unsigned int jresult ;
90857   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90858   std::string *arg2 = 0 ;
90859   Dali::ImageDimensions arg3 ;
90860   Dali::ImageDimensions *argp3 ;
90861   uint32_t result;
90862
90863   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90864   if (!jarg2) {
90865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90866     return 0;
90867   }
90868   std::string arg2_str(jarg2);
90869   arg2 = &arg2_str;
90870   argp3 = (Dali::ImageDimensions *)jarg3;
90871   if (!argp3) {
90872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
90873     return 0;
90874   }
90875   arg3 = *argp3;
90876   {
90877     try {
90878       result = (arg1)->Load((std::string const &)*arg2,arg3);
90879     } catch (std::out_of_range& e) {
90880       {
90881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90882       };
90883     } catch (std::exception& e) {
90884       {
90885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90886       };
90887     } catch (Dali::DaliException e) {
90888       {
90889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90890       };
90891     } catch (...) {
90892       {
90893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90894       };
90895     }
90896   }
90897
90898   jresult = result;
90899
90900   //argout typemap for const std::string&
90901
90902   return jresult;
90903 }
90904
90905
90906 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
90907   unsigned int jresult ;
90908   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90909   std::string *arg2 = 0 ;
90910   Dali::ImageDimensions arg3 ;
90911   Dali::FittingMode::Type arg4 ;
90912   Dali::SamplingMode::Type arg5 ;
90913   bool arg6 ;
90914   Dali::ImageDimensions *argp3 ;
90915   uint32_t result;
90916
90917   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90918   if (!jarg2) {
90919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90920     return 0;
90921   }
90922   std::string arg2_str(jarg2);
90923   arg2 = &arg2_str;
90924   argp3 = (Dali::ImageDimensions *)jarg3;
90925   if (!argp3) {
90926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
90927     return 0;
90928   }
90929   arg3 = *argp3;
90930   arg4 = (Dali::FittingMode::Type)jarg4;
90931   arg5 = (Dali::SamplingMode::Type)jarg5;
90932   arg6 = jarg6 ? true : false;
90933   {
90934     try {
90935       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
90936     } catch (std::out_of_range& e) {
90937       {
90938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90939       };
90940     } catch (std::exception& e) {
90941       {
90942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90943       };
90944     } catch (Dali::DaliException e) {
90945       {
90946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90947       };
90948     } catch (...) {
90949       {
90950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90951       };
90952     }
90953   }
90954
90955   jresult = result;
90956
90957   //argout typemap for const std::string&
90958
90959   return jresult;
90960 }
90961
90962
90963 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
90964   unsigned int jresult ;
90965   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90966   uint32_t arg2 ;
90967   bool result;
90968
90969   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90970   arg2 = (uint32_t)jarg2;
90971   {
90972     try {
90973       result = (bool)(arg1)->Cancel(arg2);
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 = result;
90994   return jresult;
90995 }
90996
90997
90998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
90999   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91000
91001   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91002   {
91003     try {
91004       (arg1)->CancelAll();
91005     } catch (std::out_of_range& e) {
91006       {
91007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91008       };
91009     } catch (std::exception& e) {
91010       {
91011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91012       };
91013     } catch (Dali::DaliException e) {
91014       {
91015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91016       };
91017     } catch (...) {
91018       {
91019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91020       };
91021     }
91022   }
91023
91024 }
91025
91026
91027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
91028   void * jresult ;
91029   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91030   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
91031
91032   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91033   {
91034     try {
91035       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
91036     } catch (std::out_of_range& e) {
91037       {
91038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91039       };
91040     } catch (std::exception& e) {
91041       {
91042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91043       };
91044     } catch (Dali::DaliException e) {
91045       {
91046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91047       };
91048     } catch (...) {
91049       {
91050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91051       };
91052     }
91053   }
91054
91055   jresult = (void *)result;
91056   return jresult;
91057 }
91058
91059
91060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
91061   void * jresult ;
91062   std::string *arg1 = 0 ;
91063   Dali::PixelData result;
91064
91065   if (!jarg1) {
91066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91067     return 0;
91068   }
91069   std::string arg1_str(jarg1);
91070   arg1 = &arg1_str;
91071   {
91072     try {
91073       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
91074     } catch (std::out_of_range& e) {
91075       {
91076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91077       };
91078     } catch (std::exception& e) {
91079       {
91080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91081       };
91082     } catch (Dali::DaliException e) {
91083       {
91084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91085       };
91086     } catch (...) {
91087       {
91088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91089       };
91090     }
91091   }
91092
91093   jresult = new Dali::PixelData((const Dali::PixelData &)result);
91094
91095   //argout typemap for const std::string&
91096
91097   return jresult;
91098 }
91099
91100
91101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
91102   void * jresult ;
91103   std::string *arg1 = 0 ;
91104   Dali::ImageDimensions arg2 ;
91105   Dali::ImageDimensions *argp2 ;
91106   Dali::PixelData result;
91107
91108   if (!jarg1) {
91109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91110     return 0;
91111   }
91112   std::string arg1_str(jarg1);
91113   arg1 = &arg1_str;
91114   argp2 = (Dali::ImageDimensions *)jarg2;
91115   if (!argp2) {
91116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91117     return 0;
91118   }
91119   arg2 = *argp2;
91120   {
91121     try {
91122       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
91123     } catch (std::out_of_range& e) {
91124       {
91125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91126       };
91127     } catch (std::exception& e) {
91128       {
91129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91130       };
91131     } catch (Dali::DaliException e) {
91132       {
91133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91134       };
91135     } catch (...) {
91136       {
91137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91138       };
91139     }
91140   }
91141
91142   jresult = new Dali::PixelData((const Dali::PixelData &)result);
91143
91144   //argout typemap for const std::string&
91145
91146   return jresult;
91147 }
91148
91149
91150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
91151   void * jresult ;
91152   std::string *arg1 = 0 ;
91153   Dali::ImageDimensions arg2 ;
91154   Dali::FittingMode::Type arg3 ;
91155   Dali::SamplingMode::Type arg4 ;
91156   bool arg5 ;
91157   Dali::ImageDimensions *argp2 ;
91158   Dali::PixelData result;
91159
91160   if (!jarg1) {
91161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91162     return 0;
91163   }
91164   std::string arg1_str(jarg1);
91165   arg1 = &arg1_str;
91166   argp2 = (Dali::ImageDimensions *)jarg2;
91167   if (!argp2) {
91168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91169     return 0;
91170   }
91171   arg2 = *argp2;
91172   arg3 = (Dali::FittingMode::Type)jarg3;
91173   arg4 = (Dali::SamplingMode::Type)jarg4;
91174   arg5 = jarg5 ? true : false;
91175   {
91176     try {
91177       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
91178     } catch (std::out_of_range& e) {
91179       {
91180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91181       };
91182     } catch (std::exception& e) {
91183       {
91184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91185       };
91186     } catch (Dali::DaliException e) {
91187       {
91188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91189       };
91190     } catch (...) {
91191       {
91192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91193       };
91194     }
91195   }
91196
91197   jresult = new Dali::PixelData((const Dali::PixelData &)result);
91198
91199   //argout typemap for const std::string&
91200
91201   return jresult;
91202 }
91203
91204
91205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
91206   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
91207
91208   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
91209   {
91210     try {
91211       delete arg1;
91212     } catch (std::out_of_range& e) {
91213       {
91214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91215       };
91216     } catch (std::exception& e) {
91217       {
91218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91219       };
91220     } catch (Dali::DaliException e) {
91221       {
91222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91223       };
91224     } catch (...) {
91225       {
91226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91227       };
91228     }
91229   }
91230
91231 }
91232
91233
91234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
91235   void * jresult ;
91236   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
91237   Dali::Actor arg2 ;
91238   Dali::Actor arg3 ;
91239   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
91240   Dali::Actor *argp2 ;
91241   Dali::Actor *argp3 ;
91242   Dali::Actor result;
91243
91244   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
91245   argp2 = (Dali::Actor *)jarg2;
91246   if (!argp2) {
91247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
91248     return 0;
91249   }
91250   arg2 = *argp2;
91251   argp3 = (Dali::Actor *)jarg3;
91252   if (!argp3) {
91253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
91254     return 0;
91255   }
91256   arg3 = *argp3;
91257   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
91258   {
91259     try {
91260       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
91261     } catch (std::out_of_range& e) {
91262       {
91263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91264       };
91265     } catch (std::exception& e) {
91266       {
91267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91268       };
91269     } catch (Dali::DaliException e) {
91270       {
91271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91272       };
91273     } catch (...) {
91274       {
91275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91276       };
91277     }
91278   }
91279
91280   jresult = new Dali::Actor((const Dali::Actor &)result);
91281   return jresult;
91282 }
91283
91284
91285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
91286   void * jresult ;
91287   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
91288
91289   {
91290     try {
91291       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
91292     } catch (std::out_of_range& e) {
91293       {
91294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91295       };
91296     } catch (std::exception& e) {
91297       {
91298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91299       };
91300     } catch (Dali::DaliException e) {
91301       {
91302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91303       };
91304     } catch (...) {
91305       {
91306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91307       };
91308     }
91309   }
91310
91311   jresult = (void *)result;
91312   return jresult;
91313 }
91314
91315
91316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
91317   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
91318   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
91319   if (director) {
91320     director->swig_connect_director(callback0);
91321   }
91322 }
91323
91324
91325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
91326   KeyboardFocusManager arg1 ;
91327   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
91328   KeyboardFocusManager *argp1 ;
91329
91330   argp1 = (KeyboardFocusManager *)jarg1;
91331   if (!argp1) {
91332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
91333     return ;
91334   }
91335   arg1 = *argp1;
91336   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
91337   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
91338   {
91339     try {
91340       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
91341     } catch (std::out_of_range& e) {
91342       {
91343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91344       };
91345     } catch (std::exception& e) {
91346       {
91347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91348       };
91349     } catch (Dali::DaliException e) {
91350       {
91351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91352       };
91353     } catch (...) {
91354       {
91355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91356       };
91357     }
91358   }
91359
91360 }
91361
91362
91363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
91364   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91365
91366   arg1 = (std::vector< unsigned int > *)jarg1;
91367   {
91368     try {
91369       (arg1)->clear();
91370     } catch (std::out_of_range& e) {
91371       {
91372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91373       };
91374     } catch (std::exception& e) {
91375       {
91376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91377       };
91378     } catch (Dali::DaliException e) {
91379       {
91380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91381       };
91382     } catch (...) {
91383       {
91384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91385       };
91386     }
91387   }
91388
91389 }
91390
91391
91392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
91393   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91394   unsigned int *arg2 = 0 ;
91395   unsigned int temp2 ;
91396
91397   arg1 = (std::vector< unsigned int > *)jarg1;
91398   temp2 = (unsigned int)jarg2;
91399   arg2 = &temp2;
91400   {
91401     try {
91402       (arg1)->push_back((unsigned int const &)*arg2);
91403     } catch (std::out_of_range& e) {
91404       {
91405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91406       };
91407     } catch (std::exception& e) {
91408       {
91409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91410       };
91411     } catch (Dali::DaliException e) {
91412       {
91413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91414       };
91415     } catch (...) {
91416       {
91417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91418       };
91419     }
91420   }
91421
91422 }
91423
91424
91425 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
91426   unsigned long jresult ;
91427   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91428   std::vector< unsigned int >::size_type result;
91429
91430   arg1 = (std::vector< unsigned int > *)jarg1;
91431   {
91432     try {
91433       result = ((std::vector< unsigned int > const *)arg1)->size();
91434     } catch (std::out_of_range& e) {
91435       {
91436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91437       };
91438     } catch (std::exception& e) {
91439       {
91440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91441       };
91442     } catch (Dali::DaliException e) {
91443       {
91444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91445       };
91446     } catch (...) {
91447       {
91448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91449       };
91450     }
91451   }
91452
91453   jresult = (unsigned long)result;
91454   return jresult;
91455 }
91456
91457
91458 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
91459   unsigned long jresult ;
91460   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91461   std::vector< unsigned int >::size_type result;
91462
91463   arg1 = (std::vector< unsigned int > *)jarg1;
91464   {
91465     try {
91466       result = ((std::vector< unsigned int > const *)arg1)->capacity();
91467     } catch (std::out_of_range& e) {
91468       {
91469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91470       };
91471     } catch (std::exception& e) {
91472       {
91473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91474       };
91475     } catch (Dali::DaliException e) {
91476       {
91477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91478       };
91479     } catch (...) {
91480       {
91481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91482       };
91483     }
91484   }
91485
91486   jresult = (unsigned long)result;
91487   return jresult;
91488 }
91489
91490
91491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
91492   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91493   std::vector< unsigned int >::size_type arg2 ;
91494
91495   arg1 = (std::vector< unsigned int > *)jarg1;
91496   arg2 = (std::vector< unsigned int >::size_type)jarg2;
91497   {
91498     try {
91499       (arg1)->reserve(arg2);
91500     } catch (std::out_of_range& e) {
91501       {
91502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91503       };
91504     } catch (std::exception& e) {
91505       {
91506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91507       };
91508     } catch (Dali::DaliException e) {
91509       {
91510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91511       };
91512     } catch (...) {
91513       {
91514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91515       };
91516     }
91517   }
91518
91519 }
91520
91521
91522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
91523   void * jresult ;
91524   std::vector< unsigned int > *result = 0 ;
91525
91526   {
91527     try {
91528       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
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 = (void *)result;
91549   return jresult;
91550 }
91551
91552
91553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
91554   void * jresult ;
91555   std::vector< unsigned int > *arg1 = 0 ;
91556   std::vector< unsigned int > *result = 0 ;
91557
91558   arg1 = (std::vector< unsigned int > *)jarg1;
91559   if (!arg1) {
91560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
91561     return 0;
91562   }
91563   {
91564     try {
91565       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
91566     } catch (std::out_of_range& e) {
91567       {
91568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91569       };
91570     } catch (std::exception& e) {
91571       {
91572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91573       };
91574     } catch (Dali::DaliException e) {
91575       {
91576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91577       };
91578     } catch (...) {
91579       {
91580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91581       };
91582     }
91583   }
91584
91585   jresult = (void *)result;
91586   return jresult;
91587 }
91588
91589
91590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
91591   void * jresult ;
91592   int arg1 ;
91593   std::vector< unsigned int > *result = 0 ;
91594
91595   arg1 = (int)jarg1;
91596   {
91597     try {
91598       try {
91599         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
91600       }
91601       catch(std::out_of_range &_e) {
91602         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91603         return 0;
91604       }
91605
91606     } catch (std::out_of_range& e) {
91607       {
91608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91609       };
91610     } catch (std::exception& e) {
91611       {
91612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91613       };
91614     } catch (Dali::DaliException e) {
91615       {
91616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91617       };
91618     } catch (...) {
91619       {
91620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91621       };
91622     }
91623   }
91624
91625   jresult = (void *)result;
91626   return jresult;
91627 }
91628
91629
91630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
91631   unsigned int jresult ;
91632   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91633   int arg2 ;
91634   unsigned int result;
91635
91636   arg1 = (std::vector< unsigned int > *)jarg1;
91637   arg2 = (int)jarg2;
91638   {
91639     try {
91640       try {
91641         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
91642       }
91643       catch(std::out_of_range &_e) {
91644         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91645         return 0;
91646       }
91647
91648     } catch (std::out_of_range& e) {
91649       {
91650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91651       };
91652     } catch (std::exception& e) {
91653       {
91654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91655       };
91656     } catch (Dali::DaliException e) {
91657       {
91658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91659       };
91660     } catch (...) {
91661       {
91662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91663       };
91664     }
91665   }
91666
91667   jresult = result;
91668   return jresult;
91669 }
91670
91671
91672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
91673   unsigned int jresult ;
91674   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91675   int arg2 ;
91676   unsigned int *result = 0 ;
91677
91678   arg1 = (std::vector< unsigned int > *)jarg1;
91679   arg2 = (int)jarg2;
91680   {
91681     try {
91682       try {
91683         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
91684       }
91685       catch(std::out_of_range &_e) {
91686         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91687         return 0;
91688       }
91689
91690     } catch (std::out_of_range& e) {
91691       {
91692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91693       };
91694     } catch (std::exception& e) {
91695       {
91696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91697       };
91698     } catch (Dali::DaliException e) {
91699       {
91700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91701       };
91702     } catch (...) {
91703       {
91704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91705       };
91706     }
91707   }
91708
91709   jresult = *result;
91710   return jresult;
91711 }
91712
91713
91714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
91715   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91716   int arg2 ;
91717   unsigned int *arg3 = 0 ;
91718   unsigned int temp3 ;
91719
91720   arg1 = (std::vector< unsigned int > *)jarg1;
91721   arg2 = (int)jarg2;
91722   temp3 = (unsigned int)jarg3;
91723   arg3 = &temp3;
91724   {
91725     try {
91726       try {
91727         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
91728       }
91729       catch(std::out_of_range &_e) {
91730         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91731         return ;
91732       }
91733
91734     } catch (std::out_of_range& e) {
91735       {
91736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91737       };
91738     } catch (std::exception& e) {
91739       {
91740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91741       };
91742     } catch (Dali::DaliException e) {
91743       {
91744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91745       };
91746     } catch (...) {
91747       {
91748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91749       };
91750     }
91751   }
91752
91753 }
91754
91755
91756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
91757   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91758   std::vector< unsigned int > *arg2 = 0 ;
91759
91760   arg1 = (std::vector< unsigned int > *)jarg1;
91761   arg2 = (std::vector< unsigned int > *)jarg2;
91762   if (!arg2) {
91763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
91764     return ;
91765   }
91766   {
91767     try {
91768       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
91769     } catch (std::out_of_range& e) {
91770       {
91771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91772       };
91773     } catch (std::exception& e) {
91774       {
91775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91776       };
91777     } catch (Dali::DaliException e) {
91778       {
91779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91780       };
91781     } catch (...) {
91782       {
91783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91784       };
91785     }
91786   }
91787
91788 }
91789
91790
91791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
91792   void * jresult ;
91793   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91794   int arg2 ;
91795   int arg3 ;
91796   std::vector< unsigned int > *result = 0 ;
91797
91798   arg1 = (std::vector< unsigned int > *)jarg1;
91799   arg2 = (int)jarg2;
91800   arg3 = (int)jarg3;
91801   {
91802     try {
91803       try {
91804         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
91805       }
91806       catch(std::out_of_range &_e) {
91807         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91808         return 0;
91809       }
91810       catch(std::invalid_argument &_e) {
91811         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
91812         return 0;
91813       }
91814
91815     } catch (std::out_of_range& e) {
91816       {
91817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91818       };
91819     } catch (std::exception& e) {
91820       {
91821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91822       };
91823     } catch (Dali::DaliException e) {
91824       {
91825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91826       };
91827     } catch (...) {
91828       {
91829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91830       };
91831     }
91832   }
91833
91834   jresult = (void *)result;
91835   return jresult;
91836 }
91837
91838
91839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
91840   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91841   int arg2 ;
91842   unsigned int *arg3 = 0 ;
91843   unsigned int temp3 ;
91844
91845   arg1 = (std::vector< unsigned int > *)jarg1;
91846   arg2 = (int)jarg2;
91847   temp3 = (unsigned int)jarg3;
91848   arg3 = &temp3;
91849   {
91850     try {
91851       try {
91852         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
91853       }
91854       catch(std::out_of_range &_e) {
91855         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91856         return ;
91857       }
91858
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_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
91882   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91883   int arg2 ;
91884   std::vector< unsigned int > *arg3 = 0 ;
91885
91886   arg1 = (std::vector< unsigned int > *)jarg1;
91887   arg2 = (int)jarg2;
91888   arg3 = (std::vector< unsigned int > *)jarg3;
91889   if (!arg3) {
91890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
91891     return ;
91892   }
91893   {
91894     try {
91895       try {
91896         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
91897       }
91898       catch(std::out_of_range &_e) {
91899         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91900         return ;
91901       }
91902
91903     } catch (std::out_of_range& e) {
91904       {
91905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91906       };
91907     } catch (std::exception& e) {
91908       {
91909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91910       };
91911     } catch (Dali::DaliException e) {
91912       {
91913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91914       };
91915     } catch (...) {
91916       {
91917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91918       };
91919     }
91920   }
91921
91922 }
91923
91924
91925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
91926   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91927   int arg2 ;
91928
91929   arg1 = (std::vector< unsigned int > *)jarg1;
91930   arg2 = (int)jarg2;
91931   {
91932     try {
91933       try {
91934         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
91935       }
91936       catch(std::out_of_range &_e) {
91937         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91938         return ;
91939       }
91940
91941     } catch (std::out_of_range& e) {
91942       {
91943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91944       };
91945     } catch (std::exception& e) {
91946       {
91947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91948       };
91949     } catch (Dali::DaliException e) {
91950       {
91951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91952       };
91953     } catch (...) {
91954       {
91955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91956       };
91957     }
91958   }
91959
91960 }
91961
91962
91963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
91964   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91965   int arg2 ;
91966   int arg3 ;
91967
91968   arg1 = (std::vector< unsigned int > *)jarg1;
91969   arg2 = (int)jarg2;
91970   arg3 = (int)jarg3;
91971   {
91972     try {
91973       try {
91974         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
91975       }
91976       catch(std::out_of_range &_e) {
91977         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91978         return ;
91979       }
91980       catch(std::invalid_argument &_e) {
91981         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
91982         return ;
91983       }
91984
91985     } catch (std::out_of_range& e) {
91986       {
91987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91988       };
91989     } catch (std::exception& e) {
91990       {
91991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91992       };
91993     } catch (Dali::DaliException e) {
91994       {
91995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91996       };
91997     } catch (...) {
91998       {
91999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92000       };
92001     }
92002   }
92003
92004 }
92005
92006
92007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
92008   void * jresult ;
92009   unsigned int *arg1 = 0 ;
92010   int arg2 ;
92011   unsigned int temp1 ;
92012   std::vector< unsigned int > *result = 0 ;
92013
92014   temp1 = (unsigned int)jarg1;
92015   arg1 = &temp1;
92016   arg2 = (int)jarg2;
92017   {
92018     try {
92019       try {
92020         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
92021       }
92022       catch(std::out_of_range &_e) {
92023         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92024         return 0;
92025       }
92026
92027     } catch (std::out_of_range& e) {
92028       {
92029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92030       };
92031     } catch (std::exception& e) {
92032       {
92033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92034       };
92035     } catch (Dali::DaliException e) {
92036       {
92037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92038       };
92039     } catch (...) {
92040       {
92041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92042       };
92043     }
92044   }
92045
92046   jresult = (void *)result;
92047   return jresult;
92048 }
92049
92050
92051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
92052   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92053
92054   arg1 = (std::vector< unsigned int > *)jarg1;
92055   {
92056     try {
92057       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
92058     } catch (std::out_of_range& e) {
92059       {
92060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92061       };
92062     } catch (std::exception& e) {
92063       {
92064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92065       };
92066     } catch (Dali::DaliException e) {
92067       {
92068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92069       };
92070     } catch (...) {
92071       {
92072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92073       };
92074     }
92075   }
92076
92077 }
92078
92079
92080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
92081   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92082   int arg2 ;
92083   int arg3 ;
92084
92085   arg1 = (std::vector< unsigned int > *)jarg1;
92086   arg2 = (int)jarg2;
92087   arg3 = (int)jarg3;
92088   {
92089     try {
92090       try {
92091         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
92092       }
92093       catch(std::out_of_range &_e) {
92094         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92095         return ;
92096       }
92097       catch(std::invalid_argument &_e) {
92098         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92099         return ;
92100       }
92101
92102     } catch (std::out_of_range& e) {
92103       {
92104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92105       };
92106     } catch (std::exception& e) {
92107       {
92108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92109       };
92110     } catch (Dali::DaliException e) {
92111       {
92112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92113       };
92114     } catch (...) {
92115       {
92116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92117       };
92118     }
92119   }
92120
92121 }
92122
92123
92124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
92125   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92126   int arg2 ;
92127   std::vector< unsigned int > *arg3 = 0 ;
92128
92129   arg1 = (std::vector< unsigned int > *)jarg1;
92130   arg2 = (int)jarg2;
92131   arg3 = (std::vector< unsigned int > *)jarg3;
92132   if (!arg3) {
92133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92134     return ;
92135   }
92136   {
92137     try {
92138       try {
92139         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
92140       }
92141       catch(std::out_of_range &_e) {
92142         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92143         return ;
92144       }
92145
92146     } catch (std::out_of_range& e) {
92147       {
92148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92149       };
92150     } catch (std::exception& e) {
92151       {
92152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92153       };
92154     } catch (Dali::DaliException e) {
92155       {
92156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92157       };
92158     } catch (...) {
92159       {
92160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92161       };
92162     }
92163   }
92164
92165 }
92166
92167
92168 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
92169   unsigned int jresult ;
92170   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92171   unsigned int *arg2 = 0 ;
92172   unsigned int temp2 ;
92173   bool result;
92174
92175   arg1 = (std::vector< unsigned int > *)jarg1;
92176   temp2 = (unsigned int)jarg2;
92177   arg2 = &temp2;
92178   {
92179     try {
92180       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
92181     } catch (std::out_of_range& e) {
92182       {
92183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92184       };
92185     } catch (std::exception& e) {
92186       {
92187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92188       };
92189     } catch (Dali::DaliException e) {
92190       {
92191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92192       };
92193     } catch (...) {
92194       {
92195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92196       };
92197     }
92198   }
92199
92200   jresult = result;
92201   return jresult;
92202 }
92203
92204
92205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
92206   int jresult ;
92207   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92208   unsigned int *arg2 = 0 ;
92209   unsigned int temp2 ;
92210   int result;
92211
92212   arg1 = (std::vector< unsigned int > *)jarg1;
92213   temp2 = (unsigned int)jarg2;
92214   arg2 = &temp2;
92215   {
92216     try {
92217       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
92218     } catch (std::out_of_range& e) {
92219       {
92220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92221       };
92222     } catch (std::exception& e) {
92223       {
92224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92225       };
92226     } catch (Dali::DaliException e) {
92227       {
92228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92229       };
92230     } catch (...) {
92231       {
92232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92233       };
92234     }
92235   }
92236
92237   jresult = result;
92238   return jresult;
92239 }
92240
92241
92242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
92243   int jresult ;
92244   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92245   unsigned int *arg2 = 0 ;
92246   unsigned int temp2 ;
92247   int result;
92248
92249   arg1 = (std::vector< unsigned int > *)jarg1;
92250   temp2 = (unsigned int)jarg2;
92251   arg2 = &temp2;
92252   {
92253     try {
92254       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
92255     } catch (std::out_of_range& e) {
92256       {
92257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92258       };
92259     } catch (std::exception& e) {
92260       {
92261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92262       };
92263     } catch (Dali::DaliException e) {
92264       {
92265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92266       };
92267     } catch (...) {
92268       {
92269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92270       };
92271     }
92272   }
92273
92274   jresult = result;
92275   return jresult;
92276 }
92277
92278
92279 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
92280   unsigned int jresult ;
92281   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92282   unsigned int *arg2 = 0 ;
92283   unsigned int temp2 ;
92284   bool result;
92285
92286   arg1 = (std::vector< unsigned int > *)jarg1;
92287   temp2 = (unsigned int)jarg2;
92288   arg2 = &temp2;
92289   {
92290     try {
92291       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
92292     } catch (std::out_of_range& e) {
92293       {
92294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92295       };
92296     } catch (std::exception& e) {
92297       {
92298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92299       };
92300     } catch (Dali::DaliException e) {
92301       {
92302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92303       };
92304     } catch (...) {
92305       {
92306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92307       };
92308     }
92309   }
92310
92311   jresult = result;
92312   return jresult;
92313 }
92314
92315
92316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
92317   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92318
92319   arg1 = (std::vector< unsigned int > *)jarg1;
92320   {
92321     try {
92322       delete arg1;
92323     } catch (std::out_of_range& e) {
92324       {
92325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92326       };
92327     } catch (std::exception& e) {
92328       {
92329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92330       };
92331     } catch (Dali::DaliException e) {
92332       {
92333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92334       };
92335     } catch (...) {
92336       {
92337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92338       };
92339     }
92340   }
92341
92342 }
92343
92344
92345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
92346   void * jresult ;
92347   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92348
92349   {
92350     try {
92351       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
92352     } catch (std::out_of_range& e) {
92353       {
92354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92355       };
92356     } catch (std::exception& e) {
92357       {
92358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92359       };
92360     } catch (Dali::DaliException e) {
92361       {
92362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92363       };
92364     } catch (...) {
92365       {
92366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92367       };
92368     }
92369   }
92370
92371   jresult = (void *)result;
92372   return jresult;
92373 }
92374
92375
92376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
92377   void * jresult ;
92378   unsigned int arg1 ;
92379   Dali::Actor arg2 ;
92380   Dali::Actor *argp2 ;
92381   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92382
92383   arg1 = (unsigned int)jarg1;
92384   argp2 = (Dali::Actor *)jarg2;
92385   if (!argp2) {
92386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92387     return 0;
92388   }
92389   arg2 = *argp2;
92390   {
92391     try {
92392       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
92393     } catch (std::out_of_range& e) {
92394       {
92395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92396       };
92397     } catch (std::exception& e) {
92398       {
92399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92400       };
92401     } catch (Dali::DaliException e) {
92402       {
92403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92404       };
92405     } catch (...) {
92406       {
92407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92408       };
92409     }
92410   }
92411
92412   jresult = (void *)result;
92413   return jresult;
92414 }
92415
92416
92417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
92418   void * jresult ;
92419   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
92420   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92421
92422   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92423   if (!arg1) {
92424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
92425     return 0;
92426   }
92427   {
92428     try {
92429       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
92430     } catch (std::out_of_range& e) {
92431       {
92432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92433       };
92434     } catch (std::exception& e) {
92435       {
92436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92437       };
92438     } catch (Dali::DaliException e) {
92439       {
92440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92441       };
92442     } catch (...) {
92443       {
92444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92445       };
92446     }
92447   }
92448
92449   jresult = (void *)result;
92450   return jresult;
92451 }
92452
92453
92454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
92455   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92456   unsigned int arg2 ;
92457
92458   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92459   arg2 = (unsigned int)jarg2;
92460   if (arg1) (arg1)->first = arg2;
92461 }
92462
92463
92464 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
92465   unsigned int jresult ;
92466   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92467   unsigned int result;
92468
92469   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92470   result = (unsigned int) ((arg1)->first);
92471   jresult = result;
92472   return jresult;
92473 }
92474
92475
92476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
92477   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92478   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
92479
92480   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92481   arg2 = (Dali::Actor *)jarg2;
92482   if (arg1) (arg1)->second = *arg2;
92483 }
92484
92485
92486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
92487   void * jresult ;
92488   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92489   Dali::Actor *result = 0 ;
92490
92491   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92492   result = (Dali::Actor *)& ((arg1)->second);
92493   jresult = (void *)result;
92494   return jresult;
92495 }
92496
92497
92498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
92499   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92500
92501   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92502   {
92503     try {
92504       delete arg1;
92505     } catch (std::out_of_range& e) {
92506       {
92507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92508       };
92509     } catch (std::exception& e) {
92510       {
92511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92512       };
92513     } catch (Dali::DaliException e) {
92514       {
92515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92516       };
92517     } catch (...) {
92518       {
92519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92520       };
92521     }
92522   }
92523
92524 }
92525
92526
92527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
92528   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92529
92530   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92531   {
92532     try {
92533       (arg1)->clear();
92534     } catch (std::out_of_range& e) {
92535       {
92536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92537       };
92538     } catch (std::exception& e) {
92539       {
92540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92541       };
92542     } catch (Dali::DaliException e) {
92543       {
92544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92545       };
92546     } catch (...) {
92547       {
92548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92549       };
92550     }
92551   }
92552
92553 }
92554
92555
92556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
92557   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92558   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
92559
92560   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92561   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
92562   if (!arg2) {
92563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
92564     return ;
92565   }
92566   {
92567     try {
92568       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
92569     } catch (std::out_of_range& e) {
92570       {
92571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92572       };
92573     } catch (std::exception& e) {
92574       {
92575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92576       };
92577     } catch (Dali::DaliException e) {
92578       {
92579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92580       };
92581     } catch (...) {
92582       {
92583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92584       };
92585     }
92586   }
92587
92588 }
92589
92590
92591 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
92592   unsigned long jresult ;
92593   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92594   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
92595
92596   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92597   {
92598     try {
92599       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
92600     } catch (std::out_of_range& e) {
92601       {
92602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92603       };
92604     } catch (std::exception& e) {
92605       {
92606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92607       };
92608     } catch (Dali::DaliException e) {
92609       {
92610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92611       };
92612     } catch (...) {
92613       {
92614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92615       };
92616     }
92617   }
92618
92619   jresult = (unsigned long)result;
92620   return jresult;
92621 }
92622
92623
92624 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
92625   unsigned long jresult ;
92626   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92627   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
92628
92629   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92630   {
92631     try {
92632       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
92633     } catch (std::out_of_range& e) {
92634       {
92635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92636       };
92637     } catch (std::exception& e) {
92638       {
92639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92640       };
92641     } catch (Dali::DaliException e) {
92642       {
92643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92644       };
92645     } catch (...) {
92646       {
92647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92648       };
92649     }
92650   }
92651
92652   jresult = (unsigned long)result;
92653   return jresult;
92654 }
92655
92656
92657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
92658   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92659   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
92660
92661   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92662   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
92663   {
92664     try {
92665       (arg1)->reserve(arg2);
92666     } catch (std::out_of_range& e) {
92667       {
92668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92669       };
92670     } catch (std::exception& e) {
92671       {
92672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92673       };
92674     } catch (Dali::DaliException e) {
92675       {
92676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92677       };
92678     } catch (...) {
92679       {
92680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92681       };
92682     }
92683   }
92684
92685 }
92686
92687
92688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
92689   void * jresult ;
92690   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
92691
92692   {
92693     try {
92694       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
92695     } catch (std::out_of_range& e) {
92696       {
92697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92698       };
92699     } catch (std::exception& e) {
92700       {
92701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92702       };
92703     } catch (Dali::DaliException e) {
92704       {
92705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92706       };
92707     } catch (...) {
92708       {
92709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92710       };
92711     }
92712   }
92713
92714   jresult = (void *)result;
92715   return jresult;
92716 }
92717
92718
92719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
92720   void * jresult ;
92721   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
92722   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
92723
92724   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92725   if (!arg1) {
92726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
92727     return 0;
92728   }
92729   {
92730     try {
92731       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);
92732     } catch (std::out_of_range& e) {
92733       {
92734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92735       };
92736     } catch (std::exception& e) {
92737       {
92738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92739       };
92740     } catch (Dali::DaliException e) {
92741       {
92742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92743       };
92744     } catch (...) {
92745       {
92746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92747       };
92748     }
92749   }
92750
92751   jresult = (void *)result;
92752   return jresult;
92753 }
92754
92755
92756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
92757   void * jresult ;
92758   int arg1 ;
92759   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
92760
92761   arg1 = (int)jarg1;
92762   {
92763     try {
92764       try {
92765         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);
92766       }
92767       catch(std::out_of_range &_e) {
92768         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92769         return 0;
92770       }
92771
92772     } catch (std::out_of_range& e) {
92773       {
92774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92775       };
92776     } catch (std::exception& e) {
92777       {
92778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92779       };
92780     } catch (Dali::DaliException e) {
92781       {
92782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92783       };
92784     } catch (...) {
92785       {
92786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92787       };
92788     }
92789   }
92790
92791   jresult = (void *)result;
92792   return jresult;
92793 }
92794
92795
92796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
92797   void * jresult ;
92798   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92799   int arg2 ;
92800   std::pair< unsigned int,Dali::Actor > result;
92801
92802   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92803   arg2 = (int)jarg2;
92804   {
92805     try {
92806       try {
92807         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
92808       }
92809       catch(std::out_of_range &_e) {
92810         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92811         return 0;
92812       }
92813
92814     } catch (std::out_of_range& e) {
92815       {
92816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92817       };
92818     } catch (std::exception& e) {
92819       {
92820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92821       };
92822     } catch (Dali::DaliException e) {
92823       {
92824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92825       };
92826     } catch (...) {
92827       {
92828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92829       };
92830     }
92831   }
92832
92833   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
92834   return jresult;
92835 }
92836
92837
92838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
92839   void * jresult ;
92840   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92841   int arg2 ;
92842   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92843
92844   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92845   arg2 = (int)jarg2;
92846   {
92847     try {
92848       try {
92849         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
92850       }
92851       catch(std::out_of_range &_e) {
92852         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92853         return 0;
92854       }
92855
92856     } catch (std::out_of_range& e) {
92857       {
92858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92859       };
92860     } catch (std::exception& e) {
92861       {
92862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92863       };
92864     } catch (Dali::DaliException e) {
92865       {
92866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92867       };
92868     } catch (...) {
92869       {
92870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92871       };
92872     }
92873   }
92874
92875   jresult = (void *)result;
92876   return jresult;
92877 }
92878
92879
92880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
92881   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92882   int arg2 ;
92883   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
92884
92885   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92886   arg2 = (int)jarg2;
92887   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
92888   if (!arg3) {
92889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
92890     return ;
92891   }
92892   {
92893     try {
92894       try {
92895         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);
92896       }
92897       catch(std::out_of_range &_e) {
92898         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92899         return ;
92900       }
92901
92902     } catch (std::out_of_range& e) {
92903       {
92904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92905       };
92906     } catch (std::exception& e) {
92907       {
92908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92909       };
92910     } catch (Dali::DaliException e) {
92911       {
92912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92913       };
92914     } catch (...) {
92915       {
92916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92917       };
92918     }
92919   }
92920
92921 }
92922
92923
92924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
92925   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92926   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
92927
92928   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92929   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
92930   if (!arg2) {
92931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
92932     return ;
92933   }
92934   {
92935     try {
92936       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);
92937     } catch (std::out_of_range& e) {
92938       {
92939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92940       };
92941     } catch (std::exception& e) {
92942       {
92943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92944       };
92945     } catch (Dali::DaliException e) {
92946       {
92947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92948       };
92949     } catch (...) {
92950       {
92951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92952       };
92953     }
92954   }
92955
92956 }
92957
92958
92959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
92960   void * jresult ;
92961   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92962   int arg2 ;
92963   int arg3 ;
92964   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
92965
92966   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92967   arg2 = (int)jarg2;
92968   arg3 = (int)jarg3;
92969   {
92970     try {
92971       try {
92972         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);
92973       }
92974       catch(std::out_of_range &_e) {
92975         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92976         return 0;
92977       }
92978       catch(std::invalid_argument &_e) {
92979         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92980         return 0;
92981       }
92982
92983     } catch (std::out_of_range& e) {
92984       {
92985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92986       };
92987     } catch (std::exception& e) {
92988       {
92989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92990       };
92991     } catch (Dali::DaliException e) {
92992       {
92993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92994       };
92995     } catch (...) {
92996       {
92997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92998       };
92999     }
93000   }
93001
93002   jresult = (void *)result;
93003   return jresult;
93004 }
93005
93006
93007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
93008   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93009   int arg2 ;
93010   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
93011
93012   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93013   arg2 = (int)jarg2;
93014   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
93015   if (!arg3) {
93016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93017     return ;
93018   }
93019   {
93020     try {
93021       try {
93022         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);
93023       }
93024       catch(std::out_of_range &_e) {
93025         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93026         return ;
93027       }
93028
93029     } catch (std::out_of_range& e) {
93030       {
93031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93032       };
93033     } catch (std::exception& e) {
93034       {
93035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93036       };
93037     } catch (Dali::DaliException e) {
93038       {
93039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93040       };
93041     } catch (...) {
93042       {
93043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93044       };
93045     }
93046   }
93047
93048 }
93049
93050
93051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93052   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93053   int arg2 ;
93054   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
93055
93056   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93057   arg2 = (int)jarg2;
93058   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
93059   if (!arg3) {
93060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93061     return ;
93062   }
93063   {
93064     try {
93065       try {
93066         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);
93067       }
93068       catch(std::out_of_range &_e) {
93069         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93070         return ;
93071       }
93072
93073     } catch (std::out_of_range& e) {
93074       {
93075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93076       };
93077     } catch (std::exception& e) {
93078       {
93079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93080       };
93081     } catch (Dali::DaliException e) {
93082       {
93083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93084       };
93085     } catch (...) {
93086       {
93087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93088       };
93089     }
93090   }
93091
93092 }
93093
93094
93095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
93096   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93097   int arg2 ;
93098
93099   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93100   arg2 = (int)jarg2;
93101   {
93102     try {
93103       try {
93104         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
93105       }
93106       catch(std::out_of_range &_e) {
93107         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93108         return ;
93109       }
93110
93111     } catch (std::out_of_range& e) {
93112       {
93113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93114       };
93115     } catch (std::exception& e) {
93116       {
93117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93118       };
93119     } catch (Dali::DaliException e) {
93120       {
93121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93122       };
93123     } catch (...) {
93124       {
93125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93126       };
93127     }
93128   }
93129
93130 }
93131
93132
93133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93134   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93135   int arg2 ;
93136   int arg3 ;
93137
93138   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93139   arg2 = (int)jarg2;
93140   arg3 = (int)jarg3;
93141   {
93142     try {
93143       try {
93144         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
93145       }
93146       catch(std::out_of_range &_e) {
93147         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93148         return ;
93149       }
93150       catch(std::invalid_argument &_e) {
93151         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93152         return ;
93153       }
93154
93155     } catch (std::out_of_range& e) {
93156       {
93157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93158       };
93159     } catch (std::exception& e) {
93160       {
93161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93162       };
93163     } catch (Dali::DaliException e) {
93164       {
93165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93166       };
93167     } catch (...) {
93168       {
93169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93170       };
93171     }
93172   }
93173
93174 }
93175
93176
93177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
93178   void * jresult ;
93179   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93180   int arg2 ;
93181   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93182
93183   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93184   if (!arg1) {
93185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93186     return 0;
93187   }
93188   arg2 = (int)jarg2;
93189   {
93190     try {
93191       try {
93192         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);
93193       }
93194       catch(std::out_of_range &_e) {
93195         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93196         return 0;
93197       }
93198
93199     } catch (std::out_of_range& e) {
93200       {
93201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93202       };
93203     } catch (std::exception& e) {
93204       {
93205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93206       };
93207     } catch (Dali::DaliException e) {
93208       {
93209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93210       };
93211     } catch (...) {
93212       {
93213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93214       };
93215     }
93216   }
93217
93218   jresult = (void *)result;
93219   return jresult;
93220 }
93221
93222
93223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
93224   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93225
93226   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93227   {
93228     try {
93229       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
93230     } catch (std::out_of_range& e) {
93231       {
93232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93233       };
93234     } catch (std::exception& e) {
93235       {
93236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93237       };
93238     } catch (Dali::DaliException e) {
93239       {
93240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93241       };
93242     } catch (...) {
93243       {
93244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93245       };
93246     }
93247   }
93248
93249 }
93250
93251
93252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93253   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93254   int arg2 ;
93255   int arg3 ;
93256
93257   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93258   arg2 = (int)jarg2;
93259   arg3 = (int)jarg3;
93260   {
93261     try {
93262       try {
93263         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93264       }
93265       catch(std::out_of_range &_e) {
93266         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93267         return ;
93268       }
93269       catch(std::invalid_argument &_e) {
93270         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93271         return ;
93272       }
93273
93274     } catch (std::out_of_range& e) {
93275       {
93276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93277       };
93278     } catch (std::exception& e) {
93279       {
93280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93281       };
93282     } catch (Dali::DaliException e) {
93283       {
93284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93285       };
93286     } catch (...) {
93287       {
93288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93289       };
93290     }
93291   }
93292
93293 }
93294
93295
93296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93297   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93298   int arg2 ;
93299   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
93300
93301   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93302   arg2 = (int)jarg2;
93303   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
93304   if (!arg3) {
93305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93306     return ;
93307   }
93308   {
93309     try {
93310       try {
93311         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);
93312       }
93313       catch(std::out_of_range &_e) {
93314         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93315         return ;
93316       }
93317
93318     } catch (std::out_of_range& e) {
93319       {
93320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93321       };
93322     } catch (std::exception& e) {
93323       {
93324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93325       };
93326     } catch (Dali::DaliException e) {
93327       {
93328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93329       };
93330     } catch (...) {
93331       {
93332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93333       };
93334     }
93335   }
93336
93337 }
93338
93339
93340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
93341   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93342
93343   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93344   {
93345     try {
93346       delete arg1;
93347     } catch (std::out_of_range& e) {
93348       {
93349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93350       };
93351     } catch (std::exception& e) {
93352       {
93353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93354       };
93355     } catch (Dali::DaliException e) {
93356       {
93357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93358       };
93359     } catch (...) {
93360       {
93361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93362       };
93363     }
93364   }
93365
93366 }
93367
93368
93369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
93370   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93371
93372   arg1 = (std::vector< Dali::Actor > *)jarg1;
93373   {
93374     try {
93375       (arg1)->clear();
93376     } catch (std::out_of_range& e) {
93377       {
93378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93379       };
93380     } catch (std::exception& e) {
93381       {
93382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93383       };
93384     } catch (Dali::DaliException e) {
93385       {
93386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93387       };
93388     } catch (...) {
93389       {
93390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93391       };
93392     }
93393   }
93394
93395 }
93396
93397
93398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
93399   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93400   Dali::Actor *arg2 = 0 ;
93401
93402   arg1 = (std::vector< Dali::Actor > *)jarg1;
93403   arg2 = (Dali::Actor *)jarg2;
93404   if (!arg2) {
93405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
93406     return ;
93407   }
93408   {
93409     try {
93410       (arg1)->push_back((Dali::Actor const &)*arg2);
93411     } catch (std::out_of_range& e) {
93412       {
93413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93414       };
93415     } catch (std::exception& e) {
93416       {
93417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93418       };
93419     } catch (Dali::DaliException e) {
93420       {
93421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93422       };
93423     } catch (...) {
93424       {
93425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93426       };
93427     }
93428   }
93429
93430 }
93431
93432
93433 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
93434   unsigned long jresult ;
93435   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93436   std::vector< Dali::Actor >::size_type result;
93437
93438   arg1 = (std::vector< Dali::Actor > *)jarg1;
93439   {
93440     try {
93441       result = ((std::vector< Dali::Actor > const *)arg1)->size();
93442     } catch (std::out_of_range& e) {
93443       {
93444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93445       };
93446     } catch (std::exception& e) {
93447       {
93448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93449       };
93450     } catch (Dali::DaliException e) {
93451       {
93452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93453       };
93454     } catch (...) {
93455       {
93456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93457       };
93458     }
93459   }
93460
93461   jresult = (unsigned long)result;
93462   return jresult;
93463 }
93464
93465
93466 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
93467   unsigned long jresult ;
93468   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93469   std::vector< Dali::Actor >::size_type result;
93470
93471   arg1 = (std::vector< Dali::Actor > *)jarg1;
93472   {
93473     try {
93474       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
93475     } catch (std::out_of_range& e) {
93476       {
93477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93478       };
93479     } catch (std::exception& e) {
93480       {
93481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93482       };
93483     } catch (Dali::DaliException e) {
93484       {
93485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93486       };
93487     } catch (...) {
93488       {
93489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93490       };
93491     }
93492   }
93493
93494   jresult = (unsigned long)result;
93495   return jresult;
93496 }
93497
93498
93499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
93500   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93501   std::vector< Dali::Actor >::size_type arg2 ;
93502
93503   arg1 = (std::vector< Dali::Actor > *)jarg1;
93504   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
93505   {
93506     try {
93507       (arg1)->reserve(arg2);
93508     } catch (std::out_of_range& e) {
93509       {
93510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93511       };
93512     } catch (std::exception& e) {
93513       {
93514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93515       };
93516     } catch (Dali::DaliException e) {
93517       {
93518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93519       };
93520     } catch (...) {
93521       {
93522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93523       };
93524     }
93525   }
93526
93527 }
93528
93529
93530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
93531   void * jresult ;
93532   std::vector< Dali::Actor > *result = 0 ;
93533
93534   {
93535     try {
93536       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
93537     } catch (std::out_of_range& e) {
93538       {
93539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93540       };
93541     } catch (std::exception& e) {
93542       {
93543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93544       };
93545     } catch (Dali::DaliException e) {
93546       {
93547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93548       };
93549     } catch (...) {
93550       {
93551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93552       };
93553     }
93554   }
93555
93556   jresult = (void *)result;
93557   return jresult;
93558 }
93559
93560
93561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
93562   void * jresult ;
93563   std::vector< Dali::Actor > *arg1 = 0 ;
93564   std::vector< Dali::Actor > *result = 0 ;
93565
93566   arg1 = (std::vector< Dali::Actor > *)jarg1;
93567   if (!arg1) {
93568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
93569     return 0;
93570   }
93571   {
93572     try {
93573       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
93574     } catch (std::out_of_range& e) {
93575       {
93576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93577       };
93578     } catch (std::exception& e) {
93579       {
93580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93581       };
93582     } catch (Dali::DaliException e) {
93583       {
93584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93585       };
93586     } catch (...) {
93587       {
93588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93589       };
93590     }
93591   }
93592
93593   jresult = (void *)result;
93594   return jresult;
93595 }
93596
93597
93598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
93599   void * jresult ;
93600   int arg1 ;
93601   std::vector< Dali::Actor > *result = 0 ;
93602
93603   arg1 = (int)jarg1;
93604   {
93605     try {
93606       try {
93607         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
93608       }
93609       catch(std::out_of_range &_e) {
93610         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93611         return 0;
93612       }
93613
93614     } catch (std::out_of_range& e) {
93615       {
93616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93617       };
93618     } catch (std::exception& e) {
93619       {
93620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93621       };
93622     } catch (Dali::DaliException e) {
93623       {
93624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93625       };
93626     } catch (...) {
93627       {
93628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93629       };
93630     }
93631   }
93632
93633   jresult = (void *)result;
93634   return jresult;
93635 }
93636
93637
93638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
93639   void * jresult ;
93640   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93641   int arg2 ;
93642   Dali::Actor result;
93643
93644   arg1 = (std::vector< Dali::Actor > *)jarg1;
93645   arg2 = (int)jarg2;
93646   {
93647     try {
93648       try {
93649         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
93650       }
93651       catch(std::out_of_range &_e) {
93652         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93653         return 0;
93654       }
93655
93656     } catch (std::out_of_range& e) {
93657       {
93658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93659       };
93660     } catch (std::exception& e) {
93661       {
93662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93663       };
93664     } catch (Dali::DaliException e) {
93665       {
93666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93667       };
93668     } catch (...) {
93669       {
93670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93671       };
93672     }
93673   }
93674
93675   jresult = new Dali::Actor((const Dali::Actor &)result);
93676   return jresult;
93677 }
93678
93679
93680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
93681   void * jresult ;
93682   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93683   int arg2 ;
93684   Dali::Actor *result = 0 ;
93685
93686   arg1 = (std::vector< Dali::Actor > *)jarg1;
93687   arg2 = (int)jarg2;
93688   {
93689     try {
93690       try {
93691         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
93692       }
93693       catch(std::out_of_range &_e) {
93694         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93695         return 0;
93696       }
93697
93698     } catch (std::out_of_range& e) {
93699       {
93700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93701       };
93702     } catch (std::exception& e) {
93703       {
93704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93705       };
93706     } catch (Dali::DaliException e) {
93707       {
93708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93709       };
93710     } catch (...) {
93711       {
93712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93713       };
93714     }
93715   }
93716
93717   jresult = (void *)result;
93718   return jresult;
93719 }
93720
93721
93722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
93723   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93724   int arg2 ;
93725   Dali::Actor *arg3 = 0 ;
93726
93727   arg1 = (std::vector< Dali::Actor > *)jarg1;
93728   arg2 = (int)jarg2;
93729   arg3 = (Dali::Actor *)jarg3;
93730   if (!arg3) {
93731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
93732     return ;
93733   }
93734   {
93735     try {
93736       try {
93737         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
93738       }
93739       catch(std::out_of_range &_e) {
93740         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93741         return ;
93742       }
93743
93744     } catch (std::out_of_range& e) {
93745       {
93746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93747       };
93748     } catch (std::exception& e) {
93749       {
93750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93751       };
93752     } catch (Dali::DaliException e) {
93753       {
93754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93755       };
93756     } catch (...) {
93757       {
93758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93759       };
93760     }
93761   }
93762
93763 }
93764
93765
93766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
93767   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93768   std::vector< Dali::Actor > *arg2 = 0 ;
93769
93770   arg1 = (std::vector< Dali::Actor > *)jarg1;
93771   arg2 = (std::vector< Dali::Actor > *)jarg2;
93772   if (!arg2) {
93773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
93774     return ;
93775   }
93776   {
93777     try {
93778       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
93779     } catch (std::out_of_range& e) {
93780       {
93781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93782       };
93783     } catch (std::exception& e) {
93784       {
93785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93786       };
93787     } catch (Dali::DaliException e) {
93788       {
93789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93790       };
93791     } catch (...) {
93792       {
93793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93794       };
93795     }
93796   }
93797
93798 }
93799
93800
93801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
93802   void * jresult ;
93803   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93804   int arg2 ;
93805   int arg3 ;
93806   std::vector< Dali::Actor > *result = 0 ;
93807
93808   arg1 = (std::vector< Dali::Actor > *)jarg1;
93809   arg2 = (int)jarg2;
93810   arg3 = (int)jarg3;
93811   {
93812     try {
93813       try {
93814         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
93815       }
93816       catch(std::out_of_range &_e) {
93817         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93818         return 0;
93819       }
93820       catch(std::invalid_argument &_e) {
93821         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93822         return 0;
93823       }
93824
93825     } catch (std::out_of_range& e) {
93826       {
93827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93828       };
93829     } catch (std::exception& e) {
93830       {
93831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93832       };
93833     } catch (Dali::DaliException e) {
93834       {
93835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93836       };
93837     } catch (...) {
93838       {
93839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93840       };
93841     }
93842   }
93843
93844   jresult = (void *)result;
93845   return jresult;
93846 }
93847
93848
93849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
93850   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93851   int arg2 ;
93852   Dali::Actor *arg3 = 0 ;
93853
93854   arg1 = (std::vector< Dali::Actor > *)jarg1;
93855   arg2 = (int)jarg2;
93856   arg3 = (Dali::Actor *)jarg3;
93857   if (!arg3) {
93858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
93859     return ;
93860   }
93861   {
93862     try {
93863       try {
93864         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
93865       }
93866       catch(std::out_of_range &_e) {
93867         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93868         return ;
93869       }
93870
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_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93894   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93895   int arg2 ;
93896   std::vector< Dali::Actor > *arg3 = 0 ;
93897
93898   arg1 = (std::vector< Dali::Actor > *)jarg1;
93899   arg2 = (int)jarg2;
93900   arg3 = (std::vector< Dali::Actor > *)jarg3;
93901   if (!arg3) {
93902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
93903     return ;
93904   }
93905   {
93906     try {
93907       try {
93908         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
93909       }
93910       catch(std::out_of_range &_e) {
93911         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93912         return ;
93913       }
93914
93915     } catch (std::out_of_range& e) {
93916       {
93917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93918       };
93919     } catch (std::exception& e) {
93920       {
93921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93922       };
93923     } catch (Dali::DaliException e) {
93924       {
93925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93926       };
93927     } catch (...) {
93928       {
93929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93930       };
93931     }
93932   }
93933
93934 }
93935
93936
93937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
93938   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93939   int arg2 ;
93940
93941   arg1 = (std::vector< Dali::Actor > *)jarg1;
93942   arg2 = (int)jarg2;
93943   {
93944     try {
93945       try {
93946         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
93947       }
93948       catch(std::out_of_range &_e) {
93949         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93950         return ;
93951       }
93952
93953     } catch (std::out_of_range& e) {
93954       {
93955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93956       };
93957     } catch (std::exception& e) {
93958       {
93959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93960       };
93961     } catch (Dali::DaliException e) {
93962       {
93963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93964       };
93965     } catch (...) {
93966       {
93967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93968       };
93969     }
93970   }
93971
93972 }
93973
93974
93975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93976   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93977   int arg2 ;
93978   int arg3 ;
93979
93980   arg1 = (std::vector< Dali::Actor > *)jarg1;
93981   arg2 = (int)jarg2;
93982   arg3 = (int)jarg3;
93983   {
93984     try {
93985       try {
93986         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
93987       }
93988       catch(std::out_of_range &_e) {
93989         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93990         return ;
93991       }
93992       catch(std::invalid_argument &_e) {
93993         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93994         return ;
93995       }
93996
93997     } catch (std::out_of_range& e) {
93998       {
93999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94000       };
94001     } catch (std::exception& e) {
94002       {
94003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94004       };
94005     } catch (Dali::DaliException e) {
94006       {
94007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94008       };
94009     } catch (...) {
94010       {
94011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94012       };
94013     }
94014   }
94015
94016 }
94017
94018
94019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
94020   void * jresult ;
94021   Dali::Actor *arg1 = 0 ;
94022   int arg2 ;
94023   std::vector< Dali::Actor > *result = 0 ;
94024
94025   arg1 = (Dali::Actor *)jarg1;
94026   if (!arg1) {
94027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94028     return 0;
94029   }
94030   arg2 = (int)jarg2;
94031   {
94032     try {
94033       try {
94034         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
94035       }
94036       catch(std::out_of_range &_e) {
94037         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94038         return 0;
94039       }
94040
94041     } catch (std::out_of_range& e) {
94042       {
94043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94044       };
94045     } catch (std::exception& e) {
94046       {
94047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94048       };
94049     } catch (Dali::DaliException e) {
94050       {
94051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94052       };
94053     } catch (...) {
94054       {
94055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94056       };
94057     }
94058   }
94059
94060   jresult = (void *)result;
94061   return jresult;
94062 }
94063
94064
94065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
94066   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94067
94068   arg1 = (std::vector< Dali::Actor > *)jarg1;
94069   {
94070     try {
94071       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
94072     } catch (std::out_of_range& e) {
94073       {
94074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94075       };
94076     } catch (std::exception& e) {
94077       {
94078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94079       };
94080     } catch (Dali::DaliException e) {
94081       {
94082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94083       };
94084     } catch (...) {
94085       {
94086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94087       };
94088     }
94089   }
94090
94091 }
94092
94093
94094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94095   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94096   int arg2 ;
94097   int arg3 ;
94098
94099   arg1 = (std::vector< Dali::Actor > *)jarg1;
94100   arg2 = (int)jarg2;
94101   arg3 = (int)jarg3;
94102   {
94103     try {
94104       try {
94105         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94106       }
94107       catch(std::out_of_range &_e) {
94108         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94109         return ;
94110       }
94111       catch(std::invalid_argument &_e) {
94112         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94113         return ;
94114       }
94115
94116     } catch (std::out_of_range& e) {
94117       {
94118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94119       };
94120     } catch (std::exception& e) {
94121       {
94122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94123       };
94124     } catch (Dali::DaliException e) {
94125       {
94126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94127       };
94128     } catch (...) {
94129       {
94130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94131       };
94132     }
94133   }
94134
94135 }
94136
94137
94138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94139   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94140   int arg2 ;
94141   std::vector< Dali::Actor > *arg3 = 0 ;
94142
94143   arg1 = (std::vector< Dali::Actor > *)jarg1;
94144   arg2 = (int)jarg2;
94145   arg3 = (std::vector< Dali::Actor > *)jarg3;
94146   if (!arg3) {
94147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94148     return ;
94149   }
94150   {
94151     try {
94152       try {
94153         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
94154       }
94155       catch(std::out_of_range &_e) {
94156         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94157         return ;
94158       }
94159
94160     } catch (std::out_of_range& e) {
94161       {
94162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94163       };
94164     } catch (std::exception& e) {
94165       {
94166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94167       };
94168     } catch (Dali::DaliException e) {
94169       {
94170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94171       };
94172     } catch (...) {
94173       {
94174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94175       };
94176     }
94177   }
94178
94179 }
94180
94181
94182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
94183   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94184
94185   arg1 = (std::vector< Dali::Actor > *)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 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
94212   unsigned int jresult ;
94213   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94214   bool result;
94215
94216   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94217   {
94218     try {
94219       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
94220     } catch (std::out_of_range& e) {
94221       {
94222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94223       };
94224     } catch (std::exception& e) {
94225       {
94226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94227       };
94228     } catch (Dali::DaliException e) {
94229       {
94230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94231       };
94232     } catch (...) {
94233       {
94234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94235       };
94236     }
94237   }
94238
94239   jresult = result;
94240   return jresult;
94241 }
94242
94243
94244 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
94245   unsigned long jresult ;
94246   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94247   std::size_t result;
94248
94249   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94250   {
94251     try {
94252       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
94253     } catch (std::out_of_range& e) {
94254       {
94255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94256       };
94257     } catch (std::exception& e) {
94258       {
94259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94260       };
94261     } catch (Dali::DaliException e) {
94262       {
94263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94264       };
94265     } catch (...) {
94266       {
94267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94268       };
94269     }
94270   }
94271
94272   jresult = (unsigned long)result;
94273   return jresult;
94274 }
94275
94276
94277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
94278   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94279   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
94280
94281   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94282   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
94283   {
94284     try {
94285       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
94286     } catch (std::out_of_range& e) {
94287       {
94288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94289       };
94290     } catch (std::exception& e) {
94291       {
94292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94293       };
94294     } catch (Dali::DaliException e) {
94295       {
94296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94297       };
94298     } catch (...) {
94299       {
94300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94301       };
94302     }
94303   }
94304
94305 }
94306
94307
94308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
94309   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94310   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
94311
94312   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94313   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
94314   {
94315     try {
94316       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
94317     } catch (std::out_of_range& e) {
94318       {
94319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94320       };
94321     } catch (std::exception& e) {
94322       {
94323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94324       };
94325     } catch (Dali::DaliException e) {
94326       {
94327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94328       };
94329     } catch (...) {
94330       {
94331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94332       };
94333     }
94334   }
94335
94336 }
94337
94338
94339 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
94340   unsigned int jresult ;
94341   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94342   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
94343   bool result;
94344
94345   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94346   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
94347   if (!arg2) {
94348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
94349     return 0;
94350   }
94351   {
94352     try {
94353       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
94354     } catch (std::out_of_range& e) {
94355       {
94356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94357       };
94358     } catch (std::exception& e) {
94359       {
94360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94361       };
94362     } catch (Dali::DaliException e) {
94363       {
94364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94365       };
94366     } catch (...) {
94367       {
94368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94369       };
94370     }
94371   }
94372
94373   jresult = result;
94374   return jresult;
94375 }
94376
94377
94378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
94379   void * jresult ;
94380   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
94381
94382   {
94383     try {
94384       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
94385     } catch (std::out_of_range& e) {
94386       {
94387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94388       };
94389     } catch (std::exception& e) {
94390       {
94391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94392       };
94393     } catch (Dali::DaliException e) {
94394       {
94395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94396       };
94397     } catch (...) {
94398       {
94399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94400       };
94401     }
94402   }
94403
94404   jresult = (void *)result;
94405   return jresult;
94406 }
94407
94408
94409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
94410   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94411
94412   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94413   {
94414     try {
94415       delete arg1;
94416     } catch (std::out_of_range& e) {
94417       {
94418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94419       };
94420     } catch (std::exception& e) {
94421       {
94422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94423       };
94424     } catch (Dali::DaliException e) {
94425       {
94426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94427       };
94428     } catch (...) {
94429       {
94430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94431       };
94432     }
94433   }
94434
94435 }
94436
94437
94438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
94439   unsigned int jresult ;
94440   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94441   bool result;
94442
94443   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94444   {
94445     try {
94446       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);
94447     } catch (std::out_of_range& e) {
94448       {
94449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94450       };
94451     } catch (std::exception& e) {
94452       {
94453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94454       };
94455     } catch (Dali::DaliException e) {
94456       {
94457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94458       };
94459     } catch (...) {
94460       {
94461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94462       };
94463     }
94464   }
94465
94466   jresult = result;
94467   return jresult;
94468 }
94469
94470
94471 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
94472   unsigned long jresult ;
94473   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94474   std::size_t result;
94475
94476   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94477   {
94478     try {
94479       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);
94480     } catch (std::out_of_range& e) {
94481       {
94482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94483       };
94484     } catch (std::exception& e) {
94485       {
94486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94487       };
94488     } catch (Dali::DaliException e) {
94489       {
94490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94491       };
94492     } catch (...) {
94493       {
94494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94495       };
94496     }
94497   }
94498
94499   jresult = (unsigned long)result;
94500   return jresult;
94501 }
94502
94503
94504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
94505   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94506   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
94507
94508   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94509   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
94510   {
94511     try {
94512       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
94513     } catch (std::out_of_range& e) {
94514       {
94515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94516       };
94517     } catch (std::exception& e) {
94518       {
94519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94520       };
94521     } catch (Dali::DaliException e) {
94522       {
94523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94524       };
94525     } catch (...) {
94526       {
94527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94528       };
94529     }
94530   }
94531
94532 }
94533
94534
94535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
94536   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94537   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
94538
94539   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94540   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
94541   {
94542     try {
94543       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
94544     } catch (std::out_of_range& e) {
94545       {
94546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94547       };
94548     } catch (std::exception& e) {
94549       {
94550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94551       };
94552     } catch (Dali::DaliException e) {
94553       {
94554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94555       };
94556     } catch (...) {
94557       {
94558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94559       };
94560     }
94561   }
94562
94563 }
94564
94565
94566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
94567   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94568   Dali::Actor arg2 ;
94569   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
94570   Dali::Actor *argp2 ;
94571
94572   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94573   argp2 = (Dali::Actor *)jarg2;
94574   if (!argp2) {
94575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
94576     return ;
94577   }
94578   arg2 = *argp2;
94579   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
94580   {
94581     try {
94582       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
94583     } catch (std::out_of_range& e) {
94584       {
94585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94586       };
94587     } catch (std::exception& e) {
94588       {
94589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94590       };
94591     } catch (Dali::DaliException e) {
94592       {
94593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94594       };
94595     } catch (...) {
94596       {
94597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94598       };
94599     }
94600   }
94601
94602 }
94603
94604
94605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
94606   void * jresult ;
94607   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
94608
94609   {
94610     try {
94611       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
94612     } catch (std::out_of_range& e) {
94613       {
94614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94615       };
94616     } catch (std::exception& e) {
94617       {
94618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94619       };
94620     } catch (Dali::DaliException e) {
94621       {
94622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94623       };
94624     } catch (...) {
94625       {
94626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94627       };
94628     }
94629   }
94630
94631   jresult = (void *)result;
94632   return jresult;
94633 }
94634
94635
94636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
94637   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94638
94639   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94640   {
94641     try {
94642       delete arg1;
94643     } catch (std::out_of_range& e) {
94644       {
94645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94646       };
94647     } catch (std::exception& e) {
94648       {
94649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94650       };
94651     } catch (Dali::DaliException e) {
94652       {
94653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94654       };
94655     } catch (...) {
94656       {
94657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94658       };
94659     }
94660   }
94661
94662 }
94663
94664
94665 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
94666   unsigned int jresult ;
94667   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94668   bool result;
94669
94670   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94671   {
94672     try {
94673       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
94674     } catch (std::out_of_range& e) {
94675       {
94676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94677       };
94678     } catch (std::exception& e) {
94679       {
94680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94681       };
94682     } catch (Dali::DaliException e) {
94683       {
94684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94685       };
94686     } catch (...) {
94687       {
94688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94689       };
94690     }
94691   }
94692
94693   jresult = result;
94694   return jresult;
94695 }
94696
94697
94698 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
94699   unsigned long jresult ;
94700   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94701   std::size_t result;
94702
94703   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94704   {
94705     try {
94706       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
94707     } catch (std::out_of_range& e) {
94708       {
94709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94710       };
94711     } catch (std::exception& e) {
94712       {
94713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94714       };
94715     } catch (Dali::DaliException e) {
94716       {
94717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94718       };
94719     } catch (...) {
94720       {
94721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94722       };
94723     }
94724   }
94725
94726   jresult = (unsigned long)result;
94727   return jresult;
94728 }
94729
94730
94731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
94732   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94733   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
94734
94735   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94736   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
94737   {
94738     try {
94739       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
94740     } catch (std::out_of_range& e) {
94741       {
94742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94743       };
94744     } catch (std::exception& e) {
94745       {
94746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94747       };
94748     } catch (Dali::DaliException e) {
94749       {
94750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94751       };
94752     } catch (...) {
94753       {
94754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94755       };
94756     }
94757   }
94758
94759 }
94760
94761
94762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
94763   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94764   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
94765
94766   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94767   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
94768   {
94769     try {
94770       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
94771     } catch (std::out_of_range& e) {
94772       {
94773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94774       };
94775     } catch (std::exception& e) {
94776       {
94777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94778       };
94779     } catch (Dali::DaliException e) {
94780       {
94781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94782       };
94783     } catch (...) {
94784       {
94785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94786       };
94787     }
94788   }
94789
94790 }
94791
94792
94793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
94794   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94795   Dali::Actor arg2 ;
94796   Dali::Actor arg3 ;
94797   Dali::Actor *argp2 ;
94798   Dali::Actor *argp3 ;
94799
94800   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94801   argp2 = (Dali::Actor *)jarg2;
94802   if (!argp2) {
94803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
94804     return ;
94805   }
94806   arg2 = *argp2;
94807   argp3 = (Dali::Actor *)jarg3;
94808   if (!argp3) {
94809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
94810     return ;
94811   }
94812   arg3 = *argp3;
94813   {
94814     try {
94815       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
94816     } catch (std::out_of_range& e) {
94817       {
94818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94819       };
94820     } catch (std::exception& e) {
94821       {
94822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94823       };
94824     } catch (Dali::DaliException e) {
94825       {
94826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94827       };
94828     } catch (...) {
94829       {
94830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94831       };
94832     }
94833   }
94834
94835 }
94836
94837
94838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
94839   void * jresult ;
94840   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
94841
94842   {
94843     try {
94844       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
94845     } catch (std::out_of_range& e) {
94846       {
94847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94848       };
94849     } catch (std::exception& e) {
94850       {
94851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94852       };
94853     } catch (Dali::DaliException e) {
94854       {
94855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94856       };
94857     } catch (...) {
94858       {
94859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94860       };
94861     }
94862   }
94863
94864   jresult = (void *)result;
94865   return jresult;
94866 }
94867
94868
94869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
94870   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94871
94872   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94873   {
94874     try {
94875       delete arg1;
94876     } catch (std::out_of_range& e) {
94877       {
94878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94879       };
94880     } catch (std::exception& e) {
94881       {
94882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94883       };
94884     } catch (Dali::DaliException e) {
94885       {
94886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94887       };
94888     } catch (...) {
94889       {
94890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94891       };
94892     }
94893   }
94894
94895 }
94896
94897
94898 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
94899   unsigned int jresult ;
94900   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94901   bool result;
94902
94903   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94904   {
94905     try {
94906       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
94907     } catch (std::out_of_range& e) {
94908       {
94909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94910       };
94911     } catch (std::exception& e) {
94912       {
94913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94914       };
94915     } catch (Dali::DaliException e) {
94916       {
94917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94918       };
94919     } catch (...) {
94920       {
94921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94922       };
94923     }
94924   }
94925
94926   jresult = result;
94927   return jresult;
94928 }
94929
94930
94931 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
94932   unsigned long jresult ;
94933   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94934   std::size_t result;
94935
94936   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94937   {
94938     try {
94939       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
94940     } catch (std::out_of_range& e) {
94941       {
94942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94943       };
94944     } catch (std::exception& e) {
94945       {
94946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94947       };
94948     } catch (Dali::DaliException e) {
94949       {
94950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94951       };
94952     } catch (...) {
94953       {
94954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94955       };
94956     }
94957   }
94958
94959   jresult = (unsigned long)result;
94960   return jresult;
94961 }
94962
94963
94964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
94965   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94966   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
94967
94968   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94969   arg2 = (void (*)(Dali::Actor,bool))jarg2;
94970   {
94971     try {
94972       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
94973     } catch (std::out_of_range& e) {
94974       {
94975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94976       };
94977     } catch (std::exception& e) {
94978       {
94979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94980       };
94981     } catch (Dali::DaliException e) {
94982       {
94983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94984       };
94985     } catch (...) {
94986       {
94987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94988       };
94989     }
94990   }
94991
94992 }
94993
94994
94995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
94996   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94997   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
94998
94999   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95000   arg2 = (void (*)(Dali::Actor,bool))jarg2;
95001   {
95002     try {
95003       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
95004     } catch (std::out_of_range& e) {
95005       {
95006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95007       };
95008     } catch (std::exception& e) {
95009       {
95010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95011       };
95012     } catch (Dali::DaliException e) {
95013       {
95014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95015       };
95016     } catch (...) {
95017       {
95018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95019       };
95020     }
95021   }
95022
95023 }
95024
95025
95026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
95027   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95028   Dali::Actor arg2 ;
95029   bool arg3 ;
95030   Dali::Actor *argp2 ;
95031
95032   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95033   argp2 = (Dali::Actor *)jarg2;
95034   if (!argp2) {
95035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95036     return ;
95037   }
95038   arg2 = *argp2;
95039   arg3 = jarg3 ? true : false;
95040   {
95041     try {
95042       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
95043     } catch (std::out_of_range& e) {
95044       {
95045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95046       };
95047     } catch (std::exception& e) {
95048       {
95049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95050       };
95051     } catch (Dali::DaliException e) {
95052       {
95053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95054       };
95055     } catch (...) {
95056       {
95057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95058       };
95059     }
95060   }
95061
95062 }
95063
95064
95065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
95066   void * jresult ;
95067   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
95068
95069   {
95070     try {
95071       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
95072     } catch (std::out_of_range& e) {
95073       {
95074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95075       };
95076     } catch (std::exception& e) {
95077       {
95078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95079       };
95080     } catch (Dali::DaliException e) {
95081       {
95082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95083       };
95084     } catch (...) {
95085       {
95086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95087       };
95088     }
95089   }
95090
95091   jresult = (void *)result;
95092   return jresult;
95093 }
95094
95095
95096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
95097   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95098
95099   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95100   {
95101     try {
95102       delete arg1;
95103     } catch (std::out_of_range& e) {
95104       {
95105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95106       };
95107     } catch (std::exception& e) {
95108       {
95109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95110       };
95111     } catch (Dali::DaliException e) {
95112       {
95113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95114       };
95115     } catch (...) {
95116       {
95117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95118       };
95119     }
95120   }
95121
95122 }
95123
95124
95125 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
95126   unsigned int jresult ;
95127   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95128   bool result;
95129
95130   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95131   {
95132     try {
95133       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);
95134     } catch (std::out_of_range& e) {
95135       {
95136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95137       };
95138     } catch (std::exception& e) {
95139       {
95140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95141       };
95142     } catch (Dali::DaliException e) {
95143       {
95144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95145       };
95146     } catch (...) {
95147       {
95148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95149       };
95150     }
95151   }
95152
95153   jresult = result;
95154   return jresult;
95155 }
95156
95157
95158 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
95159   unsigned long jresult ;
95160   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95161   std::size_t result;
95162
95163   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95164   {
95165     try {
95166       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);
95167     } catch (std::out_of_range& e) {
95168       {
95169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95170       };
95171     } catch (std::exception& e) {
95172       {
95173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95174       };
95175     } catch (Dali::DaliException e) {
95176       {
95177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95178       };
95179     } catch (...) {
95180       {
95181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95182       };
95183     }
95184   }
95185
95186   jresult = (unsigned long)result;
95187   return jresult;
95188 }
95189
95190
95191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
95192   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95193   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
95194
95195   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95196   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
95197   {
95198     try {
95199       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
95200     } catch (std::out_of_range& e) {
95201       {
95202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95203       };
95204     } catch (std::exception& e) {
95205       {
95206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95207       };
95208     } catch (Dali::DaliException e) {
95209       {
95210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95211       };
95212     } catch (...) {
95213       {
95214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95215       };
95216     }
95217   }
95218
95219 }
95220
95221
95222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95223   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95224   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
95225
95226   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95227   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
95228   {
95229     try {
95230       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
95231     } catch (std::out_of_range& e) {
95232       {
95233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95234       };
95235     } catch (std::exception& e) {
95236       {
95237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95238       };
95239     } catch (Dali::DaliException e) {
95240       {
95241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95242       };
95243     } catch (...) {
95244       {
95245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95246       };
95247     }
95248   }
95249
95250 }
95251
95252
95253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
95254   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95255   Dali::Toolkit::StyleManager arg2 ;
95256   Dali::StyleChange::Type arg3 ;
95257   Dali::Toolkit::StyleManager *argp2 ;
95258
95259   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95260   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
95261   if (!argp2) {
95262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
95263     return ;
95264   }
95265   arg2 = *argp2;
95266   arg3 = (Dali::StyleChange::Type)jarg3;
95267   {
95268     try {
95269       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
95270     } catch (std::out_of_range& e) {
95271       {
95272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95273       };
95274     } catch (std::exception& e) {
95275       {
95276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95277       };
95278     } catch (Dali::DaliException e) {
95279       {
95280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95281       };
95282     } catch (...) {
95283       {
95284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95285       };
95286     }
95287   }
95288
95289 }
95290
95291
95292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
95293   void * jresult ;
95294   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
95295
95296   {
95297     try {
95298       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
95299     } catch (std::out_of_range& e) {
95300       {
95301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95302       };
95303     } catch (std::exception& e) {
95304       {
95305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95306       };
95307     } catch (Dali::DaliException e) {
95308       {
95309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95310       };
95311     } catch (...) {
95312       {
95313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95314       };
95315     }
95316   }
95317
95318   jresult = (void *)result;
95319   return jresult;
95320 }
95321
95322
95323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
95324   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95325
95326   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95327   {
95328     try {
95329       delete arg1;
95330     } catch (std::out_of_range& e) {
95331       {
95332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95333       };
95334     } catch (std::exception& e) {
95335       {
95336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95337       };
95338     } catch (Dali::DaliException e) {
95339       {
95340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95341       };
95342     } catch (...) {
95343       {
95344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95345       };
95346     }
95347   }
95348
95349 }
95350
95351
95352 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
95353   unsigned int jresult ;
95354   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95355   bool result;
95356
95357   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95358   {
95359     try {
95360       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
95361     } catch (std::out_of_range& e) {
95362       {
95363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95364       };
95365     } catch (std::exception& e) {
95366       {
95367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95368       };
95369     } catch (Dali::DaliException e) {
95370       {
95371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95372       };
95373     } catch (...) {
95374       {
95375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95376       };
95377     }
95378   }
95379
95380   jresult = result;
95381   return jresult;
95382 }
95383
95384
95385 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
95386   unsigned long jresult ;
95387   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95388   std::size_t result;
95389
95390   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95391   {
95392     try {
95393       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
95394     } catch (std::out_of_range& e) {
95395       {
95396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95397       };
95398     } catch (std::exception& e) {
95399       {
95400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95401       };
95402     } catch (Dali::DaliException e) {
95403       {
95404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95405       };
95406     } catch (...) {
95407       {
95408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95409       };
95410     }
95411   }
95412
95413   jresult = (unsigned long)result;
95414   return jresult;
95415 }
95416
95417
95418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
95419   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95420   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
95421
95422   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95423   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
95424   {
95425     try {
95426       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
95427     } catch (std::out_of_range& e) {
95428       {
95429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95430       };
95431     } catch (std::exception& e) {
95432       {
95433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95434       };
95435     } catch (Dali::DaliException e) {
95436       {
95437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95438       };
95439     } catch (...) {
95440       {
95441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95442       };
95443     }
95444   }
95445
95446 }
95447
95448
95449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
95450   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95451   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
95452
95453   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95454   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
95455   {
95456     try {
95457       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
95458     } catch (std::out_of_range& e) {
95459       {
95460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95461       };
95462     } catch (std::exception& e) {
95463       {
95464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95465       };
95466     } catch (Dali::DaliException e) {
95467       {
95468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95469       };
95470     } catch (...) {
95471       {
95472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95473       };
95474     }
95475   }
95476
95477 }
95478
95479
95480 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
95481   unsigned int jresult ;
95482   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95483   Dali::Toolkit::Button arg2 ;
95484   Dali::Toolkit::Button *argp2 ;
95485   bool result;
95486
95487   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95488   argp2 = (Dali::Toolkit::Button *)jarg2;
95489   if (!argp2) {
95490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
95491     return 0;
95492   }
95493   arg2 = *argp2;
95494   {
95495     try {
95496       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
95497     } catch (std::out_of_range& e) {
95498       {
95499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95500       };
95501     } catch (std::exception& e) {
95502       {
95503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95504       };
95505     } catch (Dali::DaliException e) {
95506       {
95507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95508       };
95509     } catch (...) {
95510       {
95511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95512       };
95513     }
95514   }
95515
95516   jresult = result;
95517   return jresult;
95518 }
95519
95520
95521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
95522   void * jresult ;
95523   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
95524
95525   {
95526     try {
95527       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
95528     } catch (std::out_of_range& e) {
95529       {
95530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95531       };
95532     } catch (std::exception& e) {
95533       {
95534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95535       };
95536     } catch (Dali::DaliException e) {
95537       {
95538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95539       };
95540     } catch (...) {
95541       {
95542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95543       };
95544     }
95545   }
95546
95547   jresult = (void *)result;
95548   return jresult;
95549 }
95550
95551
95552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
95553   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95554
95555   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95556   {
95557     try {
95558       delete arg1;
95559     } catch (std::out_of_range& e) {
95560       {
95561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95562       };
95563     } catch (std::exception& e) {
95564       {
95565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95566       };
95567     } catch (Dali::DaliException e) {
95568       {
95569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95570       };
95571     } catch (...) {
95572       {
95573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95574       };
95575     }
95576   }
95577
95578 }
95579
95580
95581 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
95582   unsigned int jresult ;
95583   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95584   bool result;
95585
95586   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95587   {
95588     try {
95589       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
95590     } catch (std::out_of_range& e) {
95591       {
95592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95593       };
95594     } catch (std::exception& e) {
95595       {
95596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95597       };
95598     } catch (Dali::DaliException e) {
95599       {
95600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95601       };
95602     } catch (...) {
95603       {
95604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95605       };
95606     }
95607   }
95608
95609   jresult = result;
95610   return jresult;
95611 }
95612
95613
95614 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
95615   unsigned long jresult ;
95616   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95617   std::size_t result;
95618
95619   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95620   {
95621     try {
95622       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
95623     } catch (std::out_of_range& e) {
95624       {
95625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95626       };
95627     } catch (std::exception& e) {
95628       {
95629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95630       };
95631     } catch (Dali::DaliException e) {
95632       {
95633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95634       };
95635     } catch (...) {
95636       {
95637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95638       };
95639     }
95640   }
95641
95642   jresult = (unsigned long)result;
95643   return jresult;
95644 }
95645
95646
95647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
95648   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95649   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
95650
95651   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95652   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
95653   {
95654     try {
95655       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
95656     } catch (std::out_of_range& e) {
95657       {
95658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95659       };
95660     } catch (std::exception& e) {
95661       {
95662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95663       };
95664     } catch (Dali::DaliException e) {
95665       {
95666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95667       };
95668     } catch (...) {
95669       {
95670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95671       };
95672     }
95673   }
95674
95675 }
95676
95677
95678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
95679   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95680   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
95681
95682   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95683   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
95684   {
95685     try {
95686       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
95687     } catch (std::out_of_range& e) {
95688       {
95689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95690       };
95691     } catch (std::exception& e) {
95692       {
95693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95694       };
95695     } catch (Dali::DaliException e) {
95696       {
95697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95698       };
95699     } catch (...) {
95700       {
95701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95702       };
95703     }
95704   }
95705
95706 }
95707
95708
95709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
95710   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95711   Dali::Toolkit::GaussianBlurView arg2 ;
95712   Dali::Toolkit::GaussianBlurView *argp2 ;
95713
95714   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95715   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
95716   if (!argp2) {
95717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
95718     return ;
95719   }
95720   arg2 = *argp2;
95721   {
95722     try {
95723       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
95724     } catch (std::out_of_range& e) {
95725       {
95726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95727       };
95728     } catch (std::exception& e) {
95729       {
95730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95731       };
95732     } catch (Dali::DaliException e) {
95733       {
95734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95735       };
95736     } catch (...) {
95737       {
95738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95739       };
95740     }
95741   }
95742
95743 }
95744
95745
95746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
95747   void * jresult ;
95748   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
95749
95750   {
95751     try {
95752       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
95753     } catch (std::out_of_range& e) {
95754       {
95755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95756       };
95757     } catch (std::exception& e) {
95758       {
95759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95760       };
95761     } catch (Dali::DaliException e) {
95762       {
95763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95764       };
95765     } catch (...) {
95766       {
95767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95768       };
95769     }
95770   }
95771
95772   jresult = (void *)result;
95773   return jresult;
95774 }
95775
95776
95777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
95778   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95779
95780   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95781   {
95782     try {
95783       delete arg1;
95784     } catch (std::out_of_range& e) {
95785       {
95786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95787       };
95788     } catch (std::exception& e) {
95789       {
95790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95791       };
95792     } catch (Dali::DaliException e) {
95793       {
95794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95795       };
95796     } catch (...) {
95797       {
95798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95799       };
95800     }
95801   }
95802
95803 }
95804
95805
95806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
95807   unsigned int jresult ;
95808   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95809   bool result;
95810
95811   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95812   {
95813     try {
95814       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);
95815     } catch (std::out_of_range& e) {
95816       {
95817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95818       };
95819     } catch (std::exception& e) {
95820       {
95821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95822       };
95823     } catch (Dali::DaliException e) {
95824       {
95825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95826       };
95827     } catch (...) {
95828       {
95829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95830       };
95831     }
95832   }
95833
95834   jresult = result;
95835   return jresult;
95836 }
95837
95838
95839 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
95840   unsigned long jresult ;
95841   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95842   std::size_t result;
95843
95844   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95845   {
95846     try {
95847       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);
95848     } catch (std::out_of_range& e) {
95849       {
95850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95851       };
95852     } catch (std::exception& e) {
95853       {
95854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95855       };
95856     } catch (Dali::DaliException e) {
95857       {
95858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95859       };
95860     } catch (...) {
95861       {
95862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95863       };
95864     }
95865   }
95866
95867   jresult = (unsigned long)result;
95868   return jresult;
95869 }
95870
95871
95872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
95873   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95874   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
95875
95876   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95877   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
95878   {
95879     try {
95880       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
95881     } catch (std::out_of_range& e) {
95882       {
95883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95884       };
95885     } catch (std::exception& e) {
95886       {
95887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95888       };
95889     } catch (Dali::DaliException e) {
95890       {
95891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95892       };
95893     } catch (...) {
95894       {
95895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95896       };
95897     }
95898   }
95899
95900 }
95901
95902
95903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
95904   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95905   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
95906
95907   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95908   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
95909   {
95910     try {
95911       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
95912     } catch (std::out_of_range& e) {
95913       {
95914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95915       };
95916     } catch (std::exception& e) {
95917       {
95918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95919       };
95920     } catch (Dali::DaliException e) {
95921       {
95922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95923       };
95924     } catch (...) {
95925       {
95926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95927       };
95928     }
95929   }
95930
95931 }
95932
95933
95934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
95935   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95936   Dali::Toolkit::PageTurnView arg2 ;
95937   unsigned int arg3 ;
95938   bool arg4 ;
95939   Dali::Toolkit::PageTurnView *argp2 ;
95940
95941   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95942   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
95943   if (!argp2) {
95944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
95945     return ;
95946   }
95947   arg2 = *argp2;
95948   arg3 = (unsigned int)jarg3;
95949   arg4 = jarg4 ? true : false;
95950   {
95951     try {
95952       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
95953     } catch (std::out_of_range& e) {
95954       {
95955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95956       };
95957     } catch (std::exception& e) {
95958       {
95959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95960       };
95961     } catch (Dali::DaliException e) {
95962       {
95963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95964       };
95965     } catch (...) {
95966       {
95967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95968       };
95969     }
95970   }
95971
95972 }
95973
95974
95975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
95976   void * jresult ;
95977   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
95978
95979   {
95980     try {
95981       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
95982     } catch (std::out_of_range& e) {
95983       {
95984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95985       };
95986     } catch (std::exception& e) {
95987       {
95988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95989       };
95990     } catch (Dali::DaliException e) {
95991       {
95992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95993       };
95994     } catch (...) {
95995       {
95996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95997       };
95998     }
95999   }
96000
96001   jresult = (void *)result;
96002   return jresult;
96003 }
96004
96005
96006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
96007   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96008
96009   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96010   {
96011     try {
96012       delete arg1;
96013     } catch (std::out_of_range& e) {
96014       {
96015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96016       };
96017     } catch (std::exception& e) {
96018       {
96019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96020       };
96021     } catch (Dali::DaliException e) {
96022       {
96023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96024       };
96025     } catch (...) {
96026       {
96027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96028       };
96029     }
96030   }
96031
96032 }
96033
96034
96035 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
96036   unsigned int jresult ;
96037   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96038   bool result;
96039
96040   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96041   {
96042     try {
96043       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
96044     } catch (std::out_of_range& e) {
96045       {
96046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96047       };
96048     } catch (std::exception& e) {
96049       {
96050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96051       };
96052     } catch (Dali::DaliException e) {
96053       {
96054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96055       };
96056     } catch (...) {
96057       {
96058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96059       };
96060     }
96061   }
96062
96063   jresult = result;
96064   return jresult;
96065 }
96066
96067
96068 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
96069   unsigned long jresult ;
96070   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96071   std::size_t result;
96072
96073   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96074   {
96075     try {
96076       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
96077     } catch (std::out_of_range& e) {
96078       {
96079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96080       };
96081     } catch (std::exception& e) {
96082       {
96083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96084       };
96085     } catch (Dali::DaliException e) {
96086       {
96087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96088       };
96089     } catch (...) {
96090       {
96091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96092       };
96093     }
96094   }
96095
96096   jresult = (unsigned long)result;
96097   return jresult;
96098 }
96099
96100
96101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
96102   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96103   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
96104
96105   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96106   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
96107   {
96108     try {
96109       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
96110     } catch (std::out_of_range& e) {
96111       {
96112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96113       };
96114     } catch (std::exception& e) {
96115       {
96116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96117       };
96118     } catch (Dali::DaliException e) {
96119       {
96120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96121       };
96122     } catch (...) {
96123       {
96124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96125       };
96126     }
96127   }
96128
96129 }
96130
96131
96132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
96133   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96134   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
96135
96136   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96137   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
96138   {
96139     try {
96140       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
96141     } catch (std::out_of_range& e) {
96142       {
96143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96144       };
96145     } catch (std::exception& e) {
96146       {
96147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96148       };
96149     } catch (Dali::DaliException e) {
96150       {
96151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96152       };
96153     } catch (...) {
96154       {
96155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96156       };
96157     }
96158   }
96159
96160 }
96161
96162
96163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
96164   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96165   Dali::Toolkit::PageTurnView arg2 ;
96166   Dali::Toolkit::PageTurnView *argp2 ;
96167
96168   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96169   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
96170   if (!argp2) {
96171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
96172     return ;
96173   }
96174   arg2 = *argp2;
96175   {
96176     try {
96177       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
96178     } catch (std::out_of_range& e) {
96179       {
96180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96181       };
96182     } catch (std::exception& e) {
96183       {
96184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96185       };
96186     } catch (Dali::DaliException e) {
96187       {
96188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96189       };
96190     } catch (...) {
96191       {
96192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96193       };
96194     }
96195   }
96196
96197 }
96198
96199
96200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
96201   void * jresult ;
96202   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
96203
96204   {
96205     try {
96206       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
96207     } catch (std::out_of_range& e) {
96208       {
96209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96210       };
96211     } catch (std::exception& e) {
96212       {
96213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96214       };
96215     } catch (Dali::DaliException e) {
96216       {
96217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96218       };
96219     } catch (...) {
96220       {
96221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96222       };
96223     }
96224   }
96225
96226   jresult = (void *)result;
96227   return jresult;
96228 }
96229
96230
96231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
96232   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96233
96234   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96235   {
96236     try {
96237       delete arg1;
96238     } catch (std::out_of_range& e) {
96239       {
96240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96241       };
96242     } catch (std::exception& e) {
96243       {
96244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96245       };
96246     } catch (Dali::DaliException e) {
96247       {
96248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96249       };
96250     } catch (...) {
96251       {
96252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96253       };
96254     }
96255   }
96256
96257 }
96258
96259
96260 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
96261   unsigned int jresult ;
96262   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96263   bool result;
96264
96265   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96266   {
96267     try {
96268       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);
96269     } catch (std::out_of_range& e) {
96270       {
96271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96272       };
96273     } catch (std::exception& e) {
96274       {
96275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96276       };
96277     } catch (Dali::DaliException e) {
96278       {
96279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96280       };
96281     } catch (...) {
96282       {
96283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96284       };
96285     }
96286   }
96287
96288   jresult = result;
96289   return jresult;
96290 }
96291
96292
96293 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
96294   unsigned long jresult ;
96295   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96296   std::size_t result;
96297
96298   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96299   {
96300     try {
96301       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);
96302     } catch (std::out_of_range& e) {
96303       {
96304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96305       };
96306     } catch (std::exception& e) {
96307       {
96308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96309       };
96310     } catch (Dali::DaliException e) {
96311       {
96312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96313       };
96314     } catch (...) {
96315       {
96316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96317       };
96318     }
96319   }
96320
96321   jresult = (unsigned long)result;
96322   return jresult;
96323 }
96324
96325
96326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
96327   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96328   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
96329
96330   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96331   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
96332   {
96333     try {
96334       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
96335     } catch (std::out_of_range& e) {
96336       {
96337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96338       };
96339     } catch (std::exception& e) {
96340       {
96341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96342       };
96343     } catch (Dali::DaliException e) {
96344       {
96345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96346       };
96347     } catch (...) {
96348       {
96349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96350       };
96351     }
96352   }
96353
96354 }
96355
96356
96357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96358   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96359   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
96360
96361   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96362   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
96363   {
96364     try {
96365       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
96366     } catch (std::out_of_range& e) {
96367       {
96368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96369       };
96370     } catch (std::exception& e) {
96371       {
96372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96373       };
96374     } catch (Dali::DaliException e) {
96375       {
96376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96377       };
96378     } catch (...) {
96379       {
96380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96381       };
96382     }
96383   }
96384
96385 }
96386
96387
96388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
96389   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96390   Dali::Toolkit::ProgressBar arg2 ;
96391   float arg3 ;
96392   float arg4 ;
96393   Dali::Toolkit::ProgressBar *argp2 ;
96394
96395   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96396   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
96397   if (!argp2) {
96398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
96399     return ;
96400   }
96401   arg2 = *argp2;
96402   arg3 = (float)jarg3;
96403   arg4 = (float)jarg4;
96404   {
96405     try {
96406       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
96407     } catch (std::out_of_range& e) {
96408       {
96409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96410       };
96411     } catch (std::exception& e) {
96412       {
96413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96414       };
96415     } catch (Dali::DaliException e) {
96416       {
96417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96418       };
96419     } catch (...) {
96420       {
96421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96422       };
96423     }
96424   }
96425
96426 }
96427
96428
96429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
96430   void * jresult ;
96431   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
96432
96433   {
96434     try {
96435       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
96436     } catch (std::out_of_range& e) {
96437       {
96438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96439       };
96440     } catch (std::exception& e) {
96441       {
96442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96443       };
96444     } catch (Dali::DaliException e) {
96445       {
96446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96447       };
96448     } catch (...) {
96449       {
96450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96451       };
96452     }
96453   }
96454
96455   jresult = (void *)result;
96456   return jresult;
96457 }
96458
96459
96460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
96461   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96462
96463   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96464   {
96465     try {
96466       delete arg1;
96467     } catch (std::out_of_range& e) {
96468       {
96469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96470       };
96471     } catch (std::exception& e) {
96472       {
96473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96474       };
96475     } catch (Dali::DaliException e) {
96476       {
96477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96478       };
96479     } catch (...) {
96480       {
96481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96482       };
96483     }
96484   }
96485
96486 }
96487
96488
96489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
96490   unsigned int jresult ;
96491   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96492   bool result;
96493
96494   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96495   {
96496     try {
96497       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);
96498     } catch (std::out_of_range& e) {
96499       {
96500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96501       };
96502     } catch (std::exception& e) {
96503       {
96504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96505       };
96506     } catch (Dali::DaliException e) {
96507       {
96508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96509       };
96510     } catch (...) {
96511       {
96512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96513       };
96514     }
96515   }
96516
96517   jresult = result;
96518   return jresult;
96519 }
96520
96521
96522 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
96523   unsigned long jresult ;
96524   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96525   std::size_t result;
96526
96527   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96528   {
96529     try {
96530       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);
96531     } catch (std::out_of_range& e) {
96532       {
96533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96534       };
96535     } catch (std::exception& e) {
96536       {
96537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96538       };
96539     } catch (Dali::DaliException e) {
96540       {
96541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96542       };
96543     } catch (...) {
96544       {
96545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96546       };
96547     }
96548   }
96549
96550   jresult = (unsigned long)result;
96551   return jresult;
96552 }
96553
96554
96555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
96556   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96557   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
96558
96559   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96560   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
96561   {
96562     try {
96563       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
96564     } catch (std::out_of_range& e) {
96565       {
96566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96567       };
96568     } catch (std::exception& e) {
96569       {
96570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96571       };
96572     } catch (Dali::DaliException e) {
96573       {
96574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96575       };
96576     } catch (...) {
96577       {
96578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96579       };
96580     }
96581   }
96582
96583 }
96584
96585
96586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
96587   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96588   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
96589
96590   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96591   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
96592   {
96593     try {
96594       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
96595     } catch (std::out_of_range& e) {
96596       {
96597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96598       };
96599     } catch (std::exception& e) {
96600       {
96601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96602       };
96603     } catch (Dali::DaliException e) {
96604       {
96605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96606       };
96607     } catch (...) {
96608       {
96609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96610       };
96611     }
96612   }
96613
96614 }
96615
96616
96617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
96618   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96619   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
96620
96621   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96622   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
96623   if (!arg2) {
96624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
96625     return ;
96626   }
96627   {
96628     try {
96629       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
96630     } catch (std::out_of_range& e) {
96631       {
96632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96633       };
96634     } catch (std::exception& e) {
96635       {
96636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96637       };
96638     } catch (Dali::DaliException e) {
96639       {
96640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96641       };
96642     } catch (...) {
96643       {
96644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96645       };
96646     }
96647   }
96648
96649 }
96650
96651
96652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
96653   void * jresult ;
96654   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
96655
96656   {
96657     try {
96658       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
96659     } catch (std::out_of_range& e) {
96660       {
96661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96662       };
96663     } catch (std::exception& e) {
96664       {
96665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96666       };
96667     } catch (Dali::DaliException e) {
96668       {
96669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96670       };
96671     } catch (...) {
96672       {
96673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96674       };
96675     }
96676   }
96677
96678   jresult = (void *)result;
96679   return jresult;
96680 }
96681
96682
96683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
96684   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96685
96686   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96687   {
96688     try {
96689       delete arg1;
96690     } catch (std::out_of_range& e) {
96691       {
96692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96693       };
96694     } catch (std::exception& e) {
96695       {
96696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96697       };
96698     } catch (Dali::DaliException e) {
96699       {
96700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96701       };
96702     } catch (...) {
96703       {
96704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96705       };
96706     }
96707   }
96708
96709 }
96710
96711
96712 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
96713   unsigned int jresult ;
96714   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96715   bool result;
96716
96717   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96718   {
96719     try {
96720       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
96721     } catch (std::out_of_range& e) {
96722       {
96723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96724       };
96725     } catch (std::exception& e) {
96726       {
96727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96728       };
96729     } catch (Dali::DaliException e) {
96730       {
96731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96732       };
96733     } catch (...) {
96734       {
96735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96736       };
96737     }
96738   }
96739
96740   jresult = result;
96741   return jresult;
96742 }
96743
96744
96745 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
96746   unsigned long jresult ;
96747   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96748   std::size_t result;
96749
96750   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96751   {
96752     try {
96753       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
96754     } catch (std::out_of_range& e) {
96755       {
96756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96757       };
96758     } catch (std::exception& e) {
96759       {
96760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96761       };
96762     } catch (Dali::DaliException e) {
96763       {
96764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96765       };
96766     } catch (...) {
96767       {
96768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96769       };
96770     }
96771   }
96772
96773   jresult = (unsigned long)result;
96774   return jresult;
96775 }
96776
96777
96778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
96779   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96780   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
96781
96782   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96783   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
96784   {
96785     try {
96786       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
96787     } catch (std::out_of_range& e) {
96788       {
96789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96790       };
96791     } catch (std::exception& e) {
96792       {
96793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96794       };
96795     } catch (Dali::DaliException e) {
96796       {
96797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96798       };
96799     } catch (...) {
96800       {
96801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96802       };
96803     }
96804   }
96805
96806 }
96807
96808
96809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
96810   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96811   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
96812
96813   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96814   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
96815   {
96816     try {
96817       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
96818     } catch (std::out_of_range& e) {
96819       {
96820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96821       };
96822     } catch (std::exception& e) {
96823       {
96824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96825       };
96826     } catch (Dali::DaliException e) {
96827       {
96828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96829       };
96830     } catch (...) {
96831       {
96832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96833       };
96834     }
96835   }
96836
96837 }
96838
96839
96840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
96841   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96842   Dali::Vector2 *arg2 = 0 ;
96843
96844   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96845   arg2 = (Dali::Vector2 *)jarg2;
96846   if (!arg2) {
96847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
96848     return ;
96849   }
96850   {
96851     try {
96852       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
96853     } catch (std::out_of_range& e) {
96854       {
96855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96856       };
96857     } catch (std::exception& e) {
96858       {
96859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96860       };
96861     } catch (Dali::DaliException e) {
96862       {
96863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96864       };
96865     } catch (...) {
96866       {
96867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96868       };
96869     }
96870   }
96871
96872 }
96873
96874
96875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
96876   void * jresult ;
96877   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
96878
96879   {
96880     try {
96881       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
96882     } catch (std::out_of_range& e) {
96883       {
96884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96885       };
96886     } catch (std::exception& e) {
96887       {
96888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96889       };
96890     } catch (Dali::DaliException e) {
96891       {
96892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96893       };
96894     } catch (...) {
96895       {
96896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96897       };
96898     }
96899   }
96900
96901   jresult = (void *)result;
96902   return jresult;
96903 }
96904
96905
96906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
96907   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96908
96909   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96910   {
96911     try {
96912       delete arg1;
96913     } catch (std::out_of_range& e) {
96914       {
96915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96916       };
96917     } catch (std::exception& e) {
96918       {
96919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96920       };
96921     } catch (Dali::DaliException e) {
96922       {
96923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96924       };
96925     } catch (...) {
96926       {
96927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96928       };
96929     }
96930   }
96931
96932 }
96933
96934
96935
96936 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
96937   unsigned int jresult ;
96938   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96939   bool result;
96940
96941   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96942   {
96943     try {
96944       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);
96945     } catch (std::out_of_range& e) {
96946       {
96947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96948       };
96949     } catch (std::exception& e) {
96950       {
96951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96952       };
96953     } catch (Dali::DaliException e) {
96954       {
96955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96956       };
96957     } catch (...) {
96958       {
96959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96960       };
96961     }
96962   }
96963
96964   jresult = result;
96965   return jresult;
96966 }
96967
96968
96969 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
96970   unsigned long jresult ;
96971   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96972   std::size_t result;
96973
96974   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96975   {
96976     try {
96977       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);
96978     } catch (std::out_of_range& e) {
96979       {
96980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96981       };
96982     } catch (std::exception& e) {
96983       {
96984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96985       };
96986     } catch (Dali::DaliException e) {
96987       {
96988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96989       };
96990     } catch (...) {
96991       {
96992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96993       };
96994     }
96995   }
96996
96997   jresult = (unsigned long)result;
96998   return jresult;
96999 }
97000
97001
97002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
97003   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97004   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
97005
97006   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97007   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
97008   {
97009     try {
97010       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97011     } catch (std::out_of_range& e) {
97012       {
97013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97014       };
97015     } catch (std::exception& e) {
97016       {
97017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97018       };
97019     } catch (Dali::DaliException e) {
97020       {
97021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97022       };
97023     } catch (...) {
97024       {
97025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97026       };
97027     }
97028   }
97029
97030 }
97031
97032
97033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
97034   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97035   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
97036
97037   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97038   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
97039   {
97040     try {
97041       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97042     } catch (std::out_of_range& e) {
97043       {
97044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97045       };
97046     } catch (std::exception& e) {
97047       {
97048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97049       };
97050     } catch (Dali::DaliException e) {
97051       {
97052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97053       };
97054     } catch (...) {
97055       {
97056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97057       };
97058     }
97059   }
97060
97061 }
97062
97063
97064 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
97065   unsigned int jresult ;
97066   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97067   Dali::Toolkit::Control arg2 ;
97068   Dali::KeyEvent *arg3 = 0 ;
97069   Dali::Toolkit::Control *argp2 ;
97070   bool result;
97071
97072   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97073   argp2 = (Dali::Toolkit::Control *)jarg2;
97074   if (!argp2) {
97075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
97076     return 0;
97077   }
97078   arg2 = *argp2;
97079   arg3 = (Dali::KeyEvent *)jarg3;
97080   if (!arg3) {
97081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
97082     return 0;
97083   }
97084   {
97085     try {
97086       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);
97087     } catch (std::out_of_range& e) {
97088       {
97089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97090       };
97091     } catch (std::exception& e) {
97092       {
97093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97094       };
97095     } catch (Dali::DaliException e) {
97096       {
97097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97098       };
97099     } catch (...) {
97100       {
97101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97102       };
97103     }
97104   }
97105
97106   jresult = result;
97107   return jresult;
97108 }
97109
97110
97111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
97112   void * jresult ;
97113   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
97114
97115   {
97116     try {
97117       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
97118     } catch (std::out_of_range& e) {
97119       {
97120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97121       };
97122     } catch (std::exception& e) {
97123       {
97124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97125       };
97126     } catch (Dali::DaliException e) {
97127       {
97128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97129       };
97130     } catch (...) {
97131       {
97132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97133       };
97134     }
97135   }
97136
97137   jresult = (void *)result;
97138   return jresult;
97139 }
97140
97141
97142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
97143   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97144
97145   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97146   {
97147     try {
97148       delete arg1;
97149     } catch (std::out_of_range& e) {
97150       {
97151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97152       };
97153     } catch (std::exception& e) {
97154       {
97155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97156       };
97157     } catch (Dali::DaliException e) {
97158       {
97159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97160       };
97161     } catch (...) {
97162       {
97163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97164       };
97165     }
97166   }
97167
97168 }
97169
97170
97171 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
97172   unsigned int jresult ;
97173   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97174   bool result;
97175
97176   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97177   {
97178     try {
97179       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
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 (Dali::DaliException e) {
97189       {
97190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97191       };
97192     } catch (...) {
97193       {
97194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97195       };
97196     }
97197   }
97198
97199   jresult = result;
97200   return jresult;
97201 }
97202
97203
97204 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
97205   unsigned long jresult ;
97206   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97207   std::size_t result;
97208
97209   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97210   {
97211     try {
97212       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)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 (Dali::DaliException e) {
97222       {
97223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97224       };
97225     } catch (...) {
97226       {
97227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97228       };
97229     }
97230   }
97231
97232   jresult = (unsigned long)result;
97233   return jresult;
97234 }
97235
97236
97237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
97238   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97239   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
97240
97241   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97242   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
97243   {
97244     try {
97245       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
97246     } catch (std::out_of_range& e) {
97247       {
97248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97249       };
97250     } catch (std::exception& e) {
97251       {
97252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97253       };
97254     } catch (Dali::DaliException e) {
97255       {
97256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97257       };
97258     } catch (...) {
97259       {
97260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97261       };
97262     }
97263   }
97264
97265 }
97266
97267
97268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
97269   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97270   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
97271
97272   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97273   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
97274   {
97275     try {
97276       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
97277     } catch (std::out_of_range& e) {
97278       {
97279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97280       };
97281     } catch (std::exception& e) {
97282       {
97283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97284       };
97285     } catch (Dali::DaliException e) {
97286       {
97287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97288       };
97289     } catch (...) {
97290       {
97291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97292       };
97293     }
97294   }
97295
97296 }
97297
97298
97299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
97300   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97301   Dali::Toolkit::Control arg2 ;
97302   Dali::Toolkit::Control *argp2 ;
97303
97304   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97305   argp2 = (Dali::Toolkit::Control *)jarg2;
97306   if (!argp2) {
97307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
97308     return ;
97309   }
97310   arg2 = *argp2;
97311   {
97312     try {
97313       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
97314     } catch (std::out_of_range& e) {
97315       {
97316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97317       };
97318     } catch (std::exception& e) {
97319       {
97320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97321       };
97322     } catch (Dali::DaliException e) {
97323       {
97324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97325       };
97326     } catch (...) {
97327       {
97328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97329       };
97330     }
97331   }
97332
97333 }
97334
97335
97336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
97337   void * jresult ;
97338   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
97339
97340   {
97341     try {
97342       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
97343     } catch (std::out_of_range& e) {
97344       {
97345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97346       };
97347     } catch (std::exception& e) {
97348       {
97349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97350       };
97351     } catch (Dali::DaliException e) {
97352       {
97353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97354       };
97355     } catch (...) {
97356       {
97357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97358       };
97359     }
97360   }
97361
97362   jresult = (void *)result;
97363   return jresult;
97364 }
97365
97366
97367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
97368   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97369
97370   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97371   {
97372     try {
97373       delete arg1;
97374     } catch (std::out_of_range& e) {
97375       {
97376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97377       };
97378     } catch (std::exception& e) {
97379       {
97380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97381       };
97382     } catch (Dali::DaliException e) {
97383       {
97384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97385       };
97386     } catch (...) {
97387       {
97388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97389       };
97390     }
97391   }
97392
97393 }
97394
97395
97396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
97397   unsigned int jresult ;
97398   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97399   bool result;
97400
97401   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97402   {
97403     try {
97404       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
97405     } catch (std::out_of_range& e) {
97406       {
97407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97408       };
97409     } catch (std::exception& e) {
97410       {
97411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97412       };
97413     } catch (Dali::DaliException e) {
97414       {
97415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97416       };
97417     } catch (...) {
97418       {
97419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97420       };
97421     }
97422   }
97423
97424   jresult = result;
97425   return jresult;
97426 }
97427
97428
97429 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
97430   unsigned long jresult ;
97431   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97432   std::size_t result;
97433
97434   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97435   {
97436     try {
97437       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
97438     } catch (std::out_of_range& e) {
97439       {
97440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97441       };
97442     } catch (std::exception& e) {
97443       {
97444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97445       };
97446     } catch (Dali::DaliException e) {
97447       {
97448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97449       };
97450     } catch (...) {
97451       {
97452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97453       };
97454     }
97455   }
97456
97457   jresult = (unsigned long)result;
97458   return jresult;
97459 }
97460
97461
97462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
97463   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97464   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
97465
97466   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97467   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
97468   {
97469     try {
97470       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
97471     } catch (std::out_of_range& e) {
97472       {
97473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97474       };
97475     } catch (std::exception& e) {
97476       {
97477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97478       };
97479     } catch (Dali::DaliException e) {
97480       {
97481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97482       };
97483     } catch (...) {
97484       {
97485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97486       };
97487     }
97488   }
97489
97490 }
97491
97492
97493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
97494   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97495   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
97496
97497   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97498   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
97499   {
97500     try {
97501       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
97502     } catch (std::out_of_range& e) {
97503       {
97504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97505       };
97506     } catch (std::exception& e) {
97507       {
97508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97509       };
97510     } catch (Dali::DaliException e) {
97511       {
97512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97513       };
97514     } catch (...) {
97515       {
97516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97517       };
97518     }
97519   }
97520
97521 }
97522
97523
97524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
97525   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97526   Dali::Toolkit::VideoView *arg2 = 0 ;
97527
97528   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97529   arg2 = (Dali::Toolkit::VideoView *)jarg2;
97530   if (!arg2) {
97531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
97532     return ;
97533   }
97534   {
97535     try {
97536       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
97537     } catch (std::out_of_range& e) {
97538       {
97539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97540       };
97541     } catch (std::exception& e) {
97542       {
97543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97544       };
97545     } catch (Dali::DaliException e) {
97546       {
97547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97548       };
97549     } catch (...) {
97550       {
97551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97552       };
97553     }
97554   }
97555
97556 }
97557
97558
97559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
97560   void * jresult ;
97561   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
97562
97563   {
97564     try {
97565       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
97566     } catch (std::out_of_range& e) {
97567       {
97568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97569       };
97570     } catch (std::exception& e) {
97571       {
97572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97573       };
97574     } catch (Dali::DaliException e) {
97575       {
97576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97577       };
97578     } catch (...) {
97579       {
97580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97581       };
97582     }
97583   }
97584
97585   jresult = (void *)result;
97586   return jresult;
97587 }
97588
97589
97590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
97591   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97592
97593   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97594   {
97595     try {
97596       delete arg1;
97597     } catch (std::out_of_range& e) {
97598       {
97599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97600       };
97601     } catch (std::exception& e) {
97602       {
97603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97604       };
97605     } catch (Dali::DaliException e) {
97606       {
97607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97608       };
97609     } catch (...) {
97610       {
97611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97612       };
97613     }
97614   }
97615
97616 }
97617
97618
97619 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
97620   unsigned int jresult ;
97621   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97622   bool result;
97623
97624   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97625   {
97626     try {
97627       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
97628     } catch (std::out_of_range& e) {
97629       {
97630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97631       };
97632     } catch (std::exception& e) {
97633       {
97634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97635       };
97636     } catch (Dali::DaliException e) {
97637       {
97638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97639       };
97640     } catch (...) {
97641       {
97642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97643       };
97644     }
97645   }
97646
97647   jresult = result;
97648   return jresult;
97649 }
97650
97651
97652 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
97653   unsigned long jresult ;
97654   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97655   std::size_t result;
97656
97657   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97658   {
97659     try {
97660       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
97661     } catch (std::out_of_range& e) {
97662       {
97663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97664       };
97665     } catch (std::exception& e) {
97666       {
97667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97668       };
97669     } catch (Dali::DaliException e) {
97670       {
97671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97672       };
97673     } catch (...) {
97674       {
97675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97676       };
97677     }
97678   }
97679
97680   jresult = (unsigned long)result;
97681   return jresult;
97682 }
97683
97684
97685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97686   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97687   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
97688
97689   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97690   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
97691   {
97692     try {
97693       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
97694     } catch (std::out_of_range& e) {
97695       {
97696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97697       };
97698     } catch (std::exception& e) {
97699       {
97700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97701       };
97702     } catch (Dali::DaliException e) {
97703       {
97704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97705       };
97706     } catch (...) {
97707       {
97708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97709       };
97710     }
97711   }
97712
97713 }
97714
97715
97716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97717   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97718   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
97719
97720   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97721   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
97722   {
97723     try {
97724       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
97725     } catch (std::out_of_range& e) {
97726       {
97727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97728       };
97729     } catch (std::exception& e) {
97730       {
97731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97732       };
97733     } catch (Dali::DaliException e) {
97734       {
97735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97736       };
97737     } catch (...) {
97738       {
97739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97740       };
97741     }
97742   }
97743
97744 }
97745
97746
97747 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
97748   unsigned int jresult ;
97749   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97750   Dali::Toolkit::Slider arg2 ;
97751   float arg3 ;
97752   Dali::Toolkit::Slider *argp2 ;
97753   bool result;
97754
97755   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97756   argp2 = (Dali::Toolkit::Slider *)jarg2;
97757   if (!argp2) {
97758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
97759     return 0;
97760   }
97761   arg2 = *argp2;
97762   arg3 = (float)jarg3;
97763   {
97764     try {
97765       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
97766     } catch (std::out_of_range& e) {
97767       {
97768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97769       };
97770     } catch (std::exception& e) {
97771       {
97772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97773       };
97774     } catch (Dali::DaliException e) {
97775       {
97776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97777       };
97778     } catch (...) {
97779       {
97780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97781       };
97782     }
97783   }
97784
97785   jresult = result;
97786   return jresult;
97787 }
97788
97789
97790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
97791   void * jresult ;
97792   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
97793
97794   {
97795     try {
97796       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
97797     } catch (std::out_of_range& e) {
97798       {
97799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97800       };
97801     } catch (std::exception& e) {
97802       {
97803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97804       };
97805     } catch (Dali::DaliException e) {
97806       {
97807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97808       };
97809     } catch (...) {
97810       {
97811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97812       };
97813     }
97814   }
97815
97816   jresult = (void *)result;
97817   return jresult;
97818 }
97819
97820
97821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
97822   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97823
97824   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97825   {
97826     try {
97827       delete arg1;
97828     } catch (std::out_of_range& e) {
97829       {
97830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97831       };
97832     } catch (std::exception& e) {
97833       {
97834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97835       };
97836     } catch (Dali::DaliException e) {
97837       {
97838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97839       };
97840     } catch (...) {
97841       {
97842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97843       };
97844     }
97845   }
97846
97847 }
97848
97849
97850 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
97851   unsigned int jresult ;
97852   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97853   bool result;
97854
97855   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97856   {
97857     try {
97858       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
97859     } catch (std::out_of_range& e) {
97860       {
97861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97862       };
97863     } catch (std::exception& e) {
97864       {
97865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97866       };
97867     } catch (Dali::DaliException e) {
97868       {
97869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97870       };
97871     } catch (...) {
97872       {
97873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97874       };
97875     }
97876   }
97877
97878   jresult = result;
97879   return jresult;
97880 }
97881
97882
97883 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
97884   unsigned long jresult ;
97885   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97886   std::size_t result;
97887
97888   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97889   {
97890     try {
97891       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
97892     } catch (std::out_of_range& e) {
97893       {
97894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97895       };
97896     } catch (std::exception& e) {
97897       {
97898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97899       };
97900     } catch (Dali::DaliException e) {
97901       {
97902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97903       };
97904     } catch (...) {
97905       {
97906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97907       };
97908     }
97909   }
97910
97911   jresult = (unsigned long)result;
97912   return jresult;
97913 }
97914
97915
97916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
97917   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97918   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
97919
97920   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97921   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
97922   {
97923     try {
97924       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
97925     } catch (std::out_of_range& e) {
97926       {
97927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97928       };
97929     } catch (std::exception& e) {
97930       {
97931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97932       };
97933     } catch (Dali::DaliException e) {
97934       {
97935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97936       };
97937     } catch (...) {
97938       {
97939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97940       };
97941     }
97942   }
97943
97944 }
97945
97946
97947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
97948   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97949   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
97950
97951   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97952   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
97953   {
97954     try {
97955       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
97956     } catch (std::out_of_range& e) {
97957       {
97958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97959       };
97960     } catch (std::exception& e) {
97961       {
97962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97963       };
97964     } catch (Dali::DaliException e) {
97965       {
97966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97967       };
97968     } catch (...) {
97969       {
97970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97971       };
97972     }
97973   }
97974
97975 }
97976
97977
97978 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
97979   unsigned int jresult ;
97980   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97981   Dali::Toolkit::Slider arg2 ;
97982   int arg3 ;
97983   Dali::Toolkit::Slider *argp2 ;
97984   bool result;
97985
97986   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97987   argp2 = (Dali::Toolkit::Slider *)jarg2;
97988   if (!argp2) {
97989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
97990     return 0;
97991   }
97992   arg2 = *argp2;
97993   arg3 = (int)jarg3;
97994   {
97995     try {
97996       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
97997     } catch (std::out_of_range& e) {
97998       {
97999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98000       };
98001     } catch (std::exception& e) {
98002       {
98003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98004       };
98005     } catch (Dali::DaliException e) {
98006       {
98007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98008       };
98009     } catch (...) {
98010       {
98011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98012       };
98013     }
98014   }
98015
98016   jresult = result;
98017   return jresult;
98018 }
98019
98020
98021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
98022   void * jresult ;
98023   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
98024
98025   {
98026     try {
98027       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
98028     } catch (std::out_of_range& e) {
98029       {
98030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98031       };
98032     } catch (std::exception& e) {
98033       {
98034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98035       };
98036     } catch (Dali::DaliException e) {
98037       {
98038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98039       };
98040     } catch (...) {
98041       {
98042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98043       };
98044     }
98045   }
98046
98047   jresult = (void *)result;
98048   return jresult;
98049 }
98050
98051
98052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
98053   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98054
98055   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98056   {
98057     try {
98058       delete arg1;
98059     } catch (std::out_of_range& e) {
98060       {
98061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98062       };
98063     } catch (std::exception& e) {
98064       {
98065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98066       };
98067     } catch (Dali::DaliException e) {
98068       {
98069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98070       };
98071     } catch (...) {
98072       {
98073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98074       };
98075     }
98076   }
98077
98078 }
98079
98080
98081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
98082   void * jresult ;
98083   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98084
98085   {
98086     try {
98087       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
98088     } catch (std::out_of_range& e) {
98089       {
98090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98091       };
98092     } catch (std::exception& e) {
98093       {
98094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98095       };
98096     } catch (Dali::DaliException e) {
98097       {
98098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98099       };
98100     } catch (...) {
98101       {
98102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98103       };
98104     }
98105   }
98106
98107   jresult = (void *)result;
98108   return jresult;
98109 }
98110
98111
98112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
98113   void * jresult ;
98114   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
98115   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98116
98117   arg1 = (Dali::Toolkit::Ruler *)jarg1;
98118   {
98119     try {
98120       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
98121     } catch (std::out_of_range& e) {
98122       {
98123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98124       };
98125     } catch (std::exception& e) {
98126       {
98127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98128       };
98129     } catch (Dali::DaliException e) {
98130       {
98131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98132       };
98133     } catch (...) {
98134       {
98135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98136       };
98137     }
98138   }
98139
98140   jresult = (void *)result;
98141   return jresult;
98142 }
98143
98144
98145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
98146   void * jresult ;
98147   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
98148   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98149
98150   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98151   if (!arg1) {
98152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
98153     return 0;
98154   }
98155   {
98156     try {
98157       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
98158     } catch (std::out_of_range& e) {
98159       {
98160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98161       };
98162     } catch (std::exception& e) {
98163       {
98164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98165       };
98166     } catch (Dali::DaliException e) {
98167       {
98168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98169       };
98170     } catch (...) {
98171       {
98172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98173       };
98174     }
98175   }
98176
98177   jresult = (void *)result;
98178   return jresult;
98179 }
98180
98181
98182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
98183   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98184
98185   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98186   {
98187     try {
98188       delete arg1;
98189     } catch (std::out_of_range& e) {
98190       {
98191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98192       };
98193     } catch (std::exception& e) {
98194       {
98195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98196       };
98197     } catch (Dali::DaliException e) {
98198       {
98199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98200       };
98201     } catch (...) {
98202       {
98203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98204       };
98205     }
98206   }
98207
98208 }
98209
98210
98211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
98212   void * jresult ;
98213   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98214   Dali::Toolkit::Ruler *result = 0 ;
98215
98216   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98217   {
98218     try {
98219       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
98220     } catch (std::out_of_range& e) {
98221       {
98222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98223       };
98224     } catch (std::exception& e) {
98225       {
98226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98227       };
98228     } catch (Dali::DaliException e) {
98229       {
98230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98231       };
98232     } catch (...) {
98233       {
98234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98235       };
98236     }
98237   }
98238
98239   jresult = (void *)result;
98240   return jresult;
98241 }
98242
98243
98244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
98245   void * jresult ;
98246   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98247   Dali::Toolkit::Ruler *result = 0 ;
98248
98249   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98250   {
98251     try {
98252       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
98253     } catch (std::out_of_range& e) {
98254       {
98255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98256       };
98257     } catch (std::exception& e) {
98258       {
98259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98260       };
98261     } catch (Dali::DaliException e) {
98262       {
98263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98264       };
98265     } catch (...) {
98266       {
98267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98268       };
98269     }
98270   }
98271
98272   jresult = (void *)result;
98273   return jresult;
98274 }
98275
98276
98277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
98278   void * jresult ;
98279   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98280   Dali::Toolkit::Ruler *result = 0 ;
98281
98282   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98283   {
98284     try {
98285       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
98286     } catch (std::out_of_range& e) {
98287       {
98288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98289       };
98290     } catch (std::exception& e) {
98291       {
98292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98293       };
98294     } catch (Dali::DaliException e) {
98295       {
98296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98297       };
98298     } catch (...) {
98299       {
98300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98301       };
98302     }
98303   }
98304
98305   jresult = (void *)result;
98306   return jresult;
98307 }
98308
98309
98310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
98311   void * jresult ;
98312   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98313   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
98314   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98315
98316   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98317   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
98318   if (!arg2) {
98319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
98320     return 0;
98321   }
98322   {
98323     try {
98324       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
98325     } catch (std::out_of_range& e) {
98326       {
98327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98328       };
98329     } catch (std::exception& e) {
98330       {
98331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98332       };
98333     } catch (Dali::DaliException e) {
98334       {
98335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98336       };
98337     } catch (...) {
98338       {
98339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98340       };
98341     }
98342   }
98343
98344   jresult = (void *)result;
98345   return jresult;
98346 }
98347
98348
98349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
98350   void * jresult ;
98351   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98352   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
98353   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98354
98355   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98356   arg2 = (Dali::Toolkit::Ruler *)jarg2;
98357   {
98358     try {
98359       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
98360     } catch (std::out_of_range& e) {
98361       {
98362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98363       };
98364     } catch (std::exception& e) {
98365       {
98366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98367       };
98368     } catch (Dali::DaliException e) {
98369       {
98370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98371       };
98372     } catch (...) {
98373       {
98374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98375       };
98376     }
98377   }
98378
98379   jresult = (void *)result;
98380   return jresult;
98381 }
98382
98383
98384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
98385   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98386
98387   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98388   {
98389     try {
98390       (arg1)->Reset();
98391     } catch (std::out_of_range& e) {
98392       {
98393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98394       };
98395     } catch (std::exception& e) {
98396       {
98397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98398       };
98399     } catch (Dali::DaliException e) {
98400       {
98401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98402       };
98403     } catch (...) {
98404       {
98405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98406       };
98407     }
98408   }
98409
98410 }
98411
98412
98413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
98414   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98415   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
98416
98417   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98418   arg2 = (Dali::Toolkit::Ruler *)jarg2;
98419   {
98420     try {
98421       (arg1)->Reset(arg2);
98422     } catch (std::out_of_range& e) {
98423       {
98424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98425       };
98426     } catch (std::exception& e) {
98427       {
98428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98429       };
98430     } catch (Dali::DaliException e) {
98431       {
98432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98433       };
98434     } catch (...) {
98435       {
98436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98437       };
98438     }
98439   }
98440
98441 }
98442
98443
98444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
98445   void * jresult ;
98446   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98447   Dali::Toolkit::Ruler *result = 0 ;
98448
98449   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98450   {
98451     try {
98452       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
98453     } catch (std::out_of_range& e) {
98454       {
98455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98456       };
98457     } catch (std::exception& e) {
98458       {
98459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98460       };
98461     } catch (Dali::DaliException e) {
98462       {
98463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98464       };
98465     } catch (...) {
98466       {
98467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98468       };
98469     }
98470   }
98471
98472   jresult = (void *)result;
98473   return jresult;
98474 }
98475
98476
98477 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
98478   float jresult ;
98479   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98480   float arg2 ;
98481   float arg3 ;
98482   float result;
98483
98484   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98485   arg2 = (float)jarg2;
98486   arg3 = (float)jarg3;
98487   {
98488     try {
98489       result = (float)(*arg1)->Snap(arg2,arg3);
98490     } catch (std::out_of_range& e) {
98491       {
98492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98493       };
98494     } catch (std::exception& e) {
98495       {
98496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98497       };
98498     } catch (Dali::DaliException e) {
98499       {
98500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98501       };
98502     } catch (...) {
98503       {
98504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98505       };
98506     }
98507   }
98508
98509   jresult = result;
98510   return jresult;
98511 }
98512
98513
98514 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
98515   float jresult ;
98516   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98517   float arg2 ;
98518   float result;
98519
98520   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98521   arg2 = (float)jarg2;
98522   {
98523     try {
98524       result = (float)(*arg1)->Snap(arg2);
98525     } catch (std::out_of_range& e) {
98526       {
98527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98528       };
98529     } catch (std::exception& e) {
98530       {
98531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98532       };
98533     } catch (Dali::DaliException e) {
98534       {
98535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98536       };
98537     } catch (...) {
98538       {
98539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98540       };
98541     }
98542   }
98543
98544   jresult = result;
98545   return jresult;
98546 }
98547
98548
98549 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
98550   float jresult ;
98551   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98552   unsigned int arg2 ;
98553   unsigned int *arg3 = 0 ;
98554   bool arg4 ;
98555   float result;
98556
98557   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98558   arg2 = (unsigned int)jarg2;
98559   arg3 = (unsigned int *)jarg3;
98560   arg4 = jarg4 ? true : false;
98561   {
98562     try {
98563       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
98564     } catch (std::out_of_range& e) {
98565       {
98566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98567       };
98568     } catch (std::exception& e) {
98569       {
98570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98571       };
98572     } catch (Dali::DaliException e) {
98573       {
98574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98575       };
98576     } catch (...) {
98577       {
98578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98579       };
98580     }
98581   }
98582
98583   jresult = result;
98584   return jresult;
98585 }
98586
98587
98588 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
98589   unsigned int jresult ;
98590   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98591   float arg2 ;
98592   bool arg3 ;
98593   unsigned int result;
98594
98595   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98596   arg2 = (float)jarg2;
98597   arg3 = jarg3 ? true : false;
98598   {
98599     try {
98600       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
98601     } catch (std::out_of_range& e) {
98602       {
98603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98604       };
98605     } catch (std::exception& e) {
98606       {
98607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98608       };
98609     } catch (Dali::DaliException e) {
98610       {
98611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98612       };
98613     } catch (...) {
98614       {
98615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98616       };
98617     }
98618   }
98619
98620   jresult = result;
98621   return jresult;
98622 }
98623
98624
98625 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
98626   unsigned int jresult ;
98627   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98628   unsigned int result;
98629
98630   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98631   {
98632     try {
98633       result = (unsigned int)(*arg1)->GetTotalPages();
98634     } catch (std::out_of_range& e) {
98635       {
98636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98637       };
98638     } catch (std::exception& e) {
98639       {
98640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98641       };
98642     } catch (Dali::DaliException e) {
98643       {
98644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98645       };
98646     } catch (...) {
98647       {
98648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98649       };
98650     }
98651   }
98652
98653   jresult = result;
98654   return jresult;
98655 }
98656
98657
98658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
98659   int jresult ;
98660   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98661   Dali::Toolkit::Ruler::RulerType result;
98662
98663   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98664   {
98665     try {
98666       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
98667     } catch (std::out_of_range& e) {
98668       {
98669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98670       };
98671     } catch (std::exception& e) {
98672       {
98673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98674       };
98675     } catch (Dali::DaliException e) {
98676       {
98677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98678       };
98679     } catch (...) {
98680       {
98681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98682       };
98683     }
98684   }
98685
98686   jresult = (int)result;
98687   return jresult;
98688 }
98689
98690
98691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
98692   unsigned int jresult ;
98693   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98694   bool result;
98695
98696   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98697   {
98698     try {
98699       result = (bool)(*arg1)->IsEnabled();
98700     } catch (std::out_of_range& e) {
98701       {
98702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98703       };
98704     } catch (std::exception& e) {
98705       {
98706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98707       };
98708     } catch (Dali::DaliException e) {
98709       {
98710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98711       };
98712     } catch (...) {
98713       {
98714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98715       };
98716     }
98717   }
98718
98719   jresult = result;
98720   return jresult;
98721 }
98722
98723
98724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
98725   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98726
98727   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98728   {
98729     try {
98730       (*arg1)->Enable();
98731     } catch (std::out_of_range& e) {
98732       {
98733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98734       };
98735     } catch (std::exception& e) {
98736       {
98737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98738       };
98739     } catch (Dali::DaliException e) {
98740       {
98741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98742       };
98743     } catch (...) {
98744       {
98745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98746       };
98747     }
98748   }
98749
98750 }
98751
98752
98753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
98754   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98755
98756   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98757   {
98758     try {
98759       (*arg1)->Disable();
98760     } catch (std::out_of_range& e) {
98761       {
98762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98763       };
98764     } catch (std::exception& e) {
98765       {
98766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98767       };
98768     } catch (Dali::DaliException e) {
98769       {
98770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98771       };
98772     } catch (...) {
98773       {
98774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98775       };
98776     }
98777   }
98778
98779 }
98780
98781
98782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
98783   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98784   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
98785   Dali::Toolkit::RulerDomain *argp2 ;
98786
98787   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98788   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
98789   if (!argp2) {
98790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
98791     return ;
98792   }
98793   arg2 = *argp2;
98794   {
98795     try {
98796       (*arg1)->SetDomain(arg2);
98797     } catch (std::out_of_range& e) {
98798       {
98799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98800       };
98801     } catch (std::exception& e) {
98802       {
98803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98804       };
98805     } catch (Dali::DaliException e) {
98806       {
98807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98808       };
98809     } catch (...) {
98810       {
98811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98812       };
98813     }
98814   }
98815
98816 }
98817
98818
98819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
98820   void * jresult ;
98821   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98822   Dali::Toolkit::RulerDomain *result = 0 ;
98823
98824   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98825   {
98826     try {
98827       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
98828     } catch (std::out_of_range& e) {
98829       {
98830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98831       };
98832     } catch (std::exception& e) {
98833       {
98834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98835       };
98836     } catch (Dali::DaliException e) {
98837       {
98838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98839       };
98840     } catch (...) {
98841       {
98842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98843       };
98844     }
98845   }
98846
98847   jresult = (void *)result;
98848   return jresult;
98849 }
98850
98851
98852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
98853   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98854
98855   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98856   {
98857     try {
98858       (*arg1)->DisableDomain();
98859     } catch (std::out_of_range& e) {
98860       {
98861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98862       };
98863     } catch (std::exception& e) {
98864       {
98865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98866       };
98867     } catch (Dali::DaliException e) {
98868       {
98869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98870       };
98871     } catch (...) {
98872       {
98873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98874       };
98875     }
98876   }
98877
98878 }
98879
98880
98881 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
98882   float jresult ;
98883   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98884   float arg2 ;
98885   float arg3 ;
98886   float arg4 ;
98887   float result;
98888
98889   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98890   arg2 = (float)jarg2;
98891   arg3 = (float)jarg3;
98892   arg4 = (float)jarg4;
98893   {
98894     try {
98895       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
98896     } catch (std::out_of_range& e) {
98897       {
98898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98899       };
98900     } catch (std::exception& e) {
98901       {
98902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98903       };
98904     } catch (Dali::DaliException e) {
98905       {
98906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98907       };
98908     } catch (...) {
98909       {
98910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98911       };
98912     }
98913   }
98914
98915   jresult = result;
98916   return jresult;
98917 }
98918
98919
98920 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
98921   float jresult ;
98922   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98923   float arg2 ;
98924   float arg3 ;
98925   float result;
98926
98927   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98928   arg2 = (float)jarg2;
98929   arg3 = (float)jarg3;
98930   {
98931     try {
98932       result = (float)(*arg1)->Clamp(arg2,arg3);
98933     } catch (std::out_of_range& e) {
98934       {
98935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98936       };
98937     } catch (std::exception& e) {
98938       {
98939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98940       };
98941     } catch (Dali::DaliException e) {
98942       {
98943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98944       };
98945     } catch (...) {
98946       {
98947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98948       };
98949     }
98950   }
98951
98952   jresult = result;
98953   return jresult;
98954 }
98955
98956
98957 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
98958   float jresult ;
98959   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98960   float arg2 ;
98961   float result;
98962
98963   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98964   arg2 = (float)jarg2;
98965   {
98966     try {
98967       result = (float)(*arg1)->Clamp(arg2);
98968     } catch (std::out_of_range& e) {
98969       {
98970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98971       };
98972     } catch (std::exception& e) {
98973       {
98974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98975       };
98976     } catch (Dali::DaliException e) {
98977       {
98978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98979       };
98980     } catch (...) {
98981       {
98982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98983       };
98984     }
98985   }
98986
98987   jresult = result;
98988   return jresult;
98989 }
98990
98991
98992 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
98993   float jresult ;
98994   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98995   float arg2 ;
98996   float arg3 ;
98997   float arg4 ;
98998   Dali::Toolkit::ClampState *arg5 = 0 ;
98999   float result;
99000
99001   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99002   arg2 = (float)jarg2;
99003   arg3 = (float)jarg3;
99004   arg4 = (float)jarg4;
99005   arg5 = (Dali::Toolkit::ClampState *)jarg5;
99006   if (!arg5) {
99007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
99008     return 0;
99009   }
99010   {
99011     try {
99012       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
99013     } catch (std::out_of_range& e) {
99014       {
99015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99016       };
99017     } catch (std::exception& e) {
99018       {
99019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99020       };
99021     } catch (Dali::DaliException e) {
99022       {
99023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99024       };
99025     } catch (...) {
99026       {
99027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99028       };
99029     }
99030   }
99031
99032   jresult = result;
99033   return jresult;
99034 }
99035
99036
99037 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
99038   float jresult ;
99039   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99040   float arg2 ;
99041   float arg3 ;
99042   float arg4 ;
99043   float arg5 ;
99044   float result;
99045
99046   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99047   arg2 = (float)jarg2;
99048   arg3 = (float)jarg3;
99049   arg4 = (float)jarg4;
99050   arg5 = (float)jarg5;
99051   {
99052     try {
99053       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
99054     } catch (std::out_of_range& e) {
99055       {
99056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99057       };
99058     } catch (std::exception& e) {
99059       {
99060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99061       };
99062     } catch (Dali::DaliException e) {
99063       {
99064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99065       };
99066     } catch (...) {
99067       {
99068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99069       };
99070     }
99071   }
99072
99073   jresult = result;
99074   return jresult;
99075 }
99076
99077
99078 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
99079   float jresult ;
99080   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99081   float arg2 ;
99082   float arg3 ;
99083   float arg4 ;
99084   float result;
99085
99086   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99087   arg2 = (float)jarg2;
99088   arg3 = (float)jarg3;
99089   arg4 = (float)jarg4;
99090   {
99091     try {
99092       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
99093     } catch (std::out_of_range& e) {
99094       {
99095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99096       };
99097     } catch (std::exception& e) {
99098       {
99099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99100       };
99101     } catch (Dali::DaliException e) {
99102       {
99103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99104       };
99105     } catch (...) {
99106       {
99107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99108       };
99109     }
99110   }
99111
99112   jresult = result;
99113   return jresult;
99114 }
99115
99116
99117 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
99118   float jresult ;
99119   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99120   float arg2 ;
99121   float arg3 ;
99122   float result;
99123
99124   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99125   arg2 = (float)jarg2;
99126   arg3 = (float)jarg3;
99127   {
99128     try {
99129       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
99130     } catch (std::out_of_range& e) {
99131       {
99132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99133       };
99134     } catch (std::exception& e) {
99135       {
99136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99137       };
99138     } catch (Dali::DaliException e) {
99139       {
99140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99141       };
99142     } catch (...) {
99143       {
99144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99145       };
99146     }
99147   }
99148
99149   jresult = result;
99150   return jresult;
99151 }
99152
99153
99154 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
99155   float jresult ;
99156   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99157   float arg2 ;
99158   float result;
99159
99160   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99161   arg2 = (float)jarg2;
99162   {
99163     try {
99164       result = (float)(*arg1)->SnapAndClamp(arg2);
99165     } catch (std::out_of_range& e) {
99166       {
99167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99168       };
99169     } catch (std::exception& e) {
99170       {
99171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99172       };
99173     } catch (Dali::DaliException e) {
99174       {
99175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99176       };
99177     } catch (...) {
99178       {
99179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99180       };
99181     }
99182   }
99183
99184   jresult = result;
99185   return jresult;
99186 }
99187
99188
99189 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
99190   float jresult ;
99191   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99192   float arg2 ;
99193   float arg3 ;
99194   float arg4 ;
99195   float arg5 ;
99196   Dali::Toolkit::ClampState *arg6 = 0 ;
99197   float result;
99198
99199   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99200   arg2 = (float)jarg2;
99201   arg3 = (float)jarg3;
99202   arg4 = (float)jarg4;
99203   arg5 = (float)jarg5;
99204   arg6 = (Dali::Toolkit::ClampState *)jarg6;
99205   if (!arg6) {
99206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
99207     return 0;
99208   }
99209   {
99210     try {
99211       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
99212     } catch (std::out_of_range& e) {
99213       {
99214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99215       };
99216     } catch (std::exception& e) {
99217       {
99218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99219       };
99220     } catch (Dali::DaliException e) {
99221       {
99222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99223       };
99224     } catch (...) {
99225       {
99226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99227       };
99228     }
99229   }
99230
99231   jresult = result;
99232   return jresult;
99233 }
99234
99235
99236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
99237   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99238
99239   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99240   {
99241     try {
99242       (*arg1)->Reference();
99243     } catch (std::out_of_range& e) {
99244       {
99245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99246       };
99247     } catch (std::exception& e) {
99248       {
99249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99250       };
99251     } catch (Dali::DaliException e) {
99252       {
99253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99254       };
99255     } catch (...) {
99256       {
99257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99258       };
99259     }
99260   }
99261
99262 }
99263
99264
99265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
99266   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99267
99268   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99269   {
99270     try {
99271       (*arg1)->Unreference();
99272     } catch (std::out_of_range& e) {
99273       {
99274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99275       };
99276     } catch (std::exception& e) {
99277       {
99278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99279       };
99280     } catch (Dali::DaliException e) {
99281       {
99282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99283       };
99284     } catch (...) {
99285       {
99286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99287       };
99288     }
99289   }
99290
99291 }
99292
99293
99294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
99295   int jresult ;
99296   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99297   int result;
99298
99299   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99300   {
99301     try {
99302       result = (int)(*arg1)->ReferenceCount();
99303     } catch (std::out_of_range& e) {
99304       {
99305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99306       };
99307     } catch (std::exception& e) {
99308       {
99309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99310       };
99311     } catch (Dali::DaliException e) {
99312       {
99313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99314       };
99315     } catch (...) {
99316       {
99317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99318       };
99319     }
99320   }
99321
99322   jresult = result;
99323   return jresult;
99324 }
99325
99326
99327 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
99328   unsigned int jresult ;
99329   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99330   bool result;
99331
99332   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99333   {
99334     try {
99335       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
99336     } catch (std::out_of_range& e) {
99337       {
99338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99339       };
99340     } catch (std::exception& e) {
99341       {
99342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99343       };
99344     } catch (Dali::DaliException e) {
99345       {
99346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99347       };
99348     } catch (...) {
99349       {
99350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99351       };
99352     }
99353   }
99354
99355   jresult = result;
99356   return jresult;
99357 }
99358
99359
99360 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
99361   unsigned long jresult ;
99362   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99363   std::size_t result;
99364
99365   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99366   {
99367     try {
99368       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
99369     } catch (std::out_of_range& e) {
99370       {
99371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99372       };
99373     } catch (std::exception& e) {
99374       {
99375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99376       };
99377     } catch (Dali::DaliException e) {
99378       {
99379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99380       };
99381     } catch (...) {
99382       {
99383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99384       };
99385     }
99386   }
99387
99388   jresult = (unsigned long)result;
99389   return jresult;
99390 }
99391
99392
99393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
99394   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99395   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
99396
99397   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99398   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
99399   {
99400     try {
99401       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
99402     } catch (std::out_of_range& e) {
99403       {
99404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99405       };
99406     } catch (std::exception& e) {
99407       {
99408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99409       };
99410     } catch (Dali::DaliException e) {
99411       {
99412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99413       };
99414     } catch (...) {
99415       {
99416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99417       };
99418     }
99419   }
99420
99421 }
99422
99423
99424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
99425   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99426   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
99427
99428   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99429   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
99430   {
99431     try {
99432       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
99433     } catch (std::out_of_range& e) {
99434       {
99435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99436       };
99437     } catch (std::exception& e) {
99438       {
99439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99440       };
99441     } catch (Dali::DaliException e) {
99442       {
99443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99444       };
99445     } catch (...) {
99446       {
99447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99448       };
99449     }
99450   }
99451
99452 }
99453
99454
99455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
99456   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99457   Dali::Toolkit::Control arg2 ;
99458   Dali::Toolkit::Control *argp2 ;
99459
99460   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99461   argp2 = (Dali::Toolkit::Control *)jarg2;
99462   if (!argp2) {
99463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
99464     return ;
99465   }
99466   arg2 = *argp2;
99467   {
99468     try {
99469       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
99470     } catch (std::out_of_range& e) {
99471       {
99472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99473       };
99474     } catch (std::exception& e) {
99475       {
99476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99477       };
99478     } catch (Dali::DaliException e) {
99479       {
99480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99481       };
99482     } catch (...) {
99483       {
99484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99485       };
99486     }
99487   }
99488
99489 }
99490
99491
99492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
99493   void * jresult ;
99494   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
99495
99496   {
99497     try {
99498       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
99499     } catch (std::out_of_range& e) {
99500       {
99501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99502       };
99503     } catch (std::exception& e) {
99504       {
99505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99506       };
99507     } catch (Dali::DaliException e) {
99508       {
99509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99510       };
99511     } catch (...) {
99512       {
99513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99514       };
99515     }
99516   }
99517
99518   jresult = (void *)result;
99519   return jresult;
99520 }
99521
99522
99523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
99524   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99525
99526   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99527   {
99528     try {
99529       delete arg1;
99530     } catch (std::out_of_range& e) {
99531       {
99532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99533       };
99534     } catch (std::exception& e) {
99535       {
99536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99537       };
99538     } catch (Dali::DaliException e) {
99539       {
99540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99541       };
99542     } catch (...) {
99543       {
99544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99545       };
99546     }
99547   }
99548
99549 }
99550
99551 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
99552   Dali::RefObject *result = NULL;
99553
99554   if (arg1)
99555   {
99556     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
99557   }
99558   return result;
99559 }
99560
99561 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
99562     return (Dali::RefObject *)jarg1;
99563 }
99564
99565 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
99566     return (Dali::SignalObserver *)jarg1;
99567 }
99568
99569 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
99570     return (Dali::ConnectionTrackerInterface *)jarg1;
99571 }
99572
99573 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
99574     return (Dali::BaseHandle *)jarg1;
99575 }
99576
99577 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
99578     return (Dali::BaseHandle *)jarg1;
99579 }
99580
99581 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
99582     return (Dali::BaseHandle *)jarg1;
99583 }
99584
99585 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
99586     return (Dali::BaseHandle *)jarg1;
99587 }
99588
99589 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
99590     return (Dali::BaseHandle *)jarg1;
99591 }
99592
99593 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
99594     return (Dali::BaseHandle *)jarg1;
99595 }
99596
99597 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
99598     return (Dali::BaseHandle *)jarg1;
99599 }
99600
99601 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
99602     return (Dali::BaseHandle *)jarg1;
99603 }
99604
99605 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
99606     return (Dali::BaseHandle *)jarg1;
99607 }
99608
99609 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
99610     return (Dali::BaseHandle *)jarg1;
99611 }
99612
99613 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
99614     return (Dali::BaseHandle *)jarg1;
99615 }
99616
99617 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
99618     return (Dali::BaseHandle *)jarg1;
99619 }
99620
99621 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
99622     return (Dali::BaseHandle *)jarg1;
99623 }
99624
99625 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
99626     return (Dali::Handle *)jarg1;
99627 }
99628
99629 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
99630     return (Dali::Handle *)jarg1;
99631 }
99632
99633 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
99634     return (Dali::BaseHandle *)jarg1;
99635 }
99636
99637 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
99638     return (Dali::BaseHandle *)jarg1;
99639 }
99640
99641 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
99642     return (Dali::Handle *)jarg1;
99643 }
99644
99645 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
99646     return (Dali::BaseHandle *)jarg1;
99647 }
99648
99649 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
99650     return (Dali::Handle *)jarg1;
99651 }
99652
99653 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
99654     return (Dali::GestureDetector *)jarg1;
99655 }
99656
99657 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
99658     return (Dali::Gesture *)jarg1;
99659 }
99660
99661 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
99662     return (Dali::Handle *)jarg1;
99663 }
99664
99665 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
99666     return (Dali::Actor *)jarg1;
99667 }
99668
99669 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
99670     return (Dali::BaseHandle *)jarg1;
99671 }
99672
99673 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
99674     return (Dali::RefObject *)jarg1;
99675 }
99676
99677 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
99678     return (Dali::Actor *)jarg1;
99679 }
99680
99681 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
99682     return (Dali::GestureDetector *)jarg1;
99683 }
99684
99685 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
99686     return (Dali::Gesture *)jarg1;
99687 }
99688
99689 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
99690     return (Dali::GestureDetector *)jarg1;
99691 }
99692
99693 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
99694     return (Dali::Gesture *)jarg1;
99695 }
99696
99697 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
99698     return (Dali::GestureDetector *)jarg1;
99699 }
99700
99701 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
99702     return (Dali::Gesture *)jarg1;
99703 }
99704
99705 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
99706     return (Dali::BaseHandle *)jarg1;
99707 }
99708
99709 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
99710     return (Dali::Handle *)jarg1;
99711 }
99712
99713 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
99714     return (Dali::Handle *)jarg1;
99715 }
99716
99717 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
99718     return (Dali::Handle *)jarg1;
99719 }
99720
99721 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
99722     return (Dali::Image *)jarg1;
99723 }
99724
99725 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
99726     return (Dali::Image *)jarg1;
99727 }
99728
99729 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
99730     return (Dali::Image *)jarg1;
99731 }
99732
99733 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
99734     return (Dali::RefObject *)jarg1;
99735 }
99736
99737 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
99738     return (Dali::Image *)jarg1;
99739 }
99740
99741 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
99742     return (Dali::Image *)jarg1;
99743 }
99744
99745 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
99746     return (Dali::ResourceImage *)jarg1;
99747 }
99748
99749 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
99750     return (Dali::Actor *)jarg1;
99751 }
99752
99753 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
99754     return (Dali::BaseHandle *)jarg1;
99755 }
99756
99757 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
99758     return (Dali::BaseHandle *)jarg1;
99759 }
99760
99761 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
99762     return (Dali::BaseHandle *)jarg1;
99763 }
99764
99765 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
99766     return (Dali::CustomActorImpl *)jarg1;
99767 }
99768
99769 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
99770     return (Dali::CustomActor *)jarg1;
99771 }
99772
99773 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
99774     return (Dali::BaseHandle *)jarg1;
99775 }
99776
99777 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
99778     return (Dali::Toolkit::Control *)jarg1;
99779 }
99780
99781 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
99782     return (Dali::Toolkit::Control *)jarg1;
99783 }
99784
99785 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
99786     return (Dali::Toolkit::Button *)jarg1;
99787 }
99788
99789 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
99790     return (Dali::Toolkit::Button *)jarg1;
99791 }
99792
99793 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
99794     return (Dali::Toolkit::Button *)jarg1;
99795 }
99796
99797 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
99798     return (Dali::Toolkit::Control *)jarg1;
99799 }
99800
99801 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
99802     return (Dali::Toolkit::Control *)jarg1;
99803 }
99804
99805 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
99806     return (Dali::Toolkit::Control *)jarg1;
99807 }
99808
99809 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
99810     return (Dali::Toolkit::Control *)jarg1;
99811 }
99812
99813 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
99814     return (Dali::Toolkit::Control *)jarg1;
99815 }
99816
99817 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
99818     return (Dali::RefObject *)jarg1;
99819 }
99820
99821 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
99822     return (Dali::Toolkit::Scrollable *)jarg1;
99823 }
99824
99825 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
99826     return (Dali::BaseHandle *)jarg1;
99827 }
99828
99829 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
99830     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
99831 }
99832
99833 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
99834     return (Dali::RefObject *)jarg1;
99835 }
99836
99837 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
99838     return (Dali::Toolkit::Ruler *)jarg1;
99839 }
99840
99841 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
99842     return (Dali::Toolkit::Ruler *)jarg1;
99843 }
99844
99845 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
99846     return (Dali::Toolkit::Scrollable *)jarg1;
99847 }
99848
99849 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
99850     return (Dali::Toolkit::Control *)jarg1;
99851 }
99852
99853
99854 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
99855     return (Dali::Toolkit::Control *)jarg1;
99856 }
99857
99858 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
99859     return (Dali::BaseHandle *)jarg1;
99860 }
99861
99862 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
99863     return (Dali::BaseHandle *)jarg1;
99864 }
99865
99866 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
99867     return (Dali::Toolkit::Control *)jarg1;
99868 }
99869
99870 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
99871     return (Dali::Toolkit::Control *)jarg1;
99872 }
99873
99874 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
99875     return (Dali::Toolkit::Control *)jarg1;
99876 }
99877
99878 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
99879     return (Dali::Toolkit::Control *)jarg1;
99880 }
99881
99882 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
99883     return (Dali::Toolkit::Control *)jarg1;
99884 }
99885
99886 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
99887     return (Dali::Toolkit::Control *)jarg1;
99888 }
99889
99890 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
99891     return (Dali::Toolkit::PageTurnView *)jarg1;
99892 }
99893
99894 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
99895     return (Dali::Toolkit::PageTurnView *)jarg1;
99896 }
99897
99898 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
99899     return (Dali::Toolkit::Button *)jarg1;
99900 }
99901
99902 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
99903     return (Dali::BaseHandle *)jarg1;
99904 }
99905
99906 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
99907     return (Dali::BaseHandle *)jarg1;
99908 }
99909
99910 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
99911     return (Dali::BaseHandle *)jarg1;
99912 }
99913
99914 /*
99915  * Widget binding
99916  */
99917 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
99918     return (Dali::BaseHandle *)jarg1;
99919 }
99920
99921 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
99922     return (Dali::BaseObject *)jarg1;
99923 }
99924
99925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
99926   void * jresult ;
99927   Dali::Widget result;
99928
99929   {
99930     try {
99931       result = Dali::Widget::New();
99932     } catch (std::out_of_range& e) {
99933       {
99934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99935       };
99936     } catch (std::exception& e) {
99937       {
99938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99939       };
99940     } catch (...) {
99941       {
99942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99943       };
99944     }
99945   }
99946   jresult = new Dali::Widget((const Dali::Widget &)result);
99947   return jresult;
99948 }
99949
99950
99951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
99952   void * jresult ;
99953   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
99954   Dali::Widget result;
99955
99956   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
99957
99958   if (!arg1) {
99959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
99960     return 0;
99961   }
99962   {
99963     try {
99964       jresult = new Dali::Widget(arg1);
99965     } catch (std::out_of_range& e) {
99966       {
99967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99968       };
99969     } catch (std::exception& e) {
99970       {
99971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99972       };
99973     } catch (...) {
99974       {
99975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99976       };
99977     }
99978   }
99979   return jresult;
99980 }
99981
99982
99983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
99984   void * jresult ;
99985   Dali::Widget *result = 0 ;
99986
99987   {
99988     try {
99989       result = (Dali::Widget *)new Dali::Widget();
99990     } catch (std::out_of_range& e) {
99991       {
99992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99993       };
99994     } catch (std::exception& e) {
99995       {
99996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99997       };
99998     } catch (...) {
99999       {
100000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100001       };
100002     }
100003   }
100004   jresult = (void *)result;
100005   return jresult;
100006 }
100007
100008
100009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
100010   void * jresult ;
100011   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
100012   Dali::Widget *arg2 = 0 ;
100013   Dali::Widget *result = 0 ;
100014
100015   arg1 = (Dali::Widget *)jarg1;
100016   arg2 = (Dali::Widget *)jarg2;
100017   if (!arg2) {
100018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
100019     return 0;
100020   }
100021   {
100022     try {
100023       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
100024     } catch (std::out_of_range& e) {
100025       {
100026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100027       };
100028     } catch (std::exception& e) {
100029       {
100030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100031       };
100032     } catch (...) {
100033       {
100034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100035       };
100036     }
100037   }
100038   jresult = (void *)result;
100039   return jresult;
100040 }
100041
100042
100043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
100044   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
100045
100046   arg1 = (Dali::Widget *)jarg1;
100047   {
100048     try {
100049       delete arg1;
100050     } catch (std::out_of_range& e) {
100051       {
100052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100053       };
100054     } catch (std::exception& e) {
100055       {
100056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100057       };
100058     } catch (...) {
100059       {
100060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100061       };
100062     }
100063   }
100064 }
100065
100066
100067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
100068   void * jresult ;
100069   SwigDirector_WidgetImpl* result;
100070   {
100071     try {
100072       result = new SwigDirector_WidgetImpl();
100073     } catch (std::out_of_range& e) {
100074       {
100075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100076       };
100077     } catch (std::exception& e) {
100078       {
100079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100080       };
100081     } catch (...) {
100082       {
100083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100084       };
100085     }
100086   }
100087   jresult = result;
100088   return jresult;
100089 }
100090
100091
100092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
100093   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100094   std::string *arg2 = 0 ;
100095   Dali::Window arg3 ;
100096   Dali::Window *argp3 ;
100097
100098   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100099   if (!jarg2) {
100100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100101     return ;
100102   }
100103   std::string arg2_str(jarg2);
100104   arg2 = &arg2_str;
100105   argp3 = (Dali::Window *)jarg3;
100106   if (!argp3) {
100107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100108     return ;
100109   }
100110   arg3 = *argp3;
100111   {
100112     try {
100113       (arg1)->OnCreate((std::string const &)*arg2,arg3);
100114     } catch (std::out_of_range& e) {
100115       {
100116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100117       };
100118     } catch (std::exception& e) {
100119       {
100120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100121       };
100122     } catch (...) {
100123       {
100124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100125       };
100126     }
100127   }
100128 }
100129
100130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
100131   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100132   std::string *arg2 = 0 ;
100133   Dali::Window arg3 ;
100134   Dali::Window *argp3 ;
100135
100136   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100137   if (!jarg2) {
100138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100139     return ;
100140   }
100141   std::string arg2_str(jarg2);
100142   arg2 = &arg2_str;
100143   argp3 = (Dali::Window *)jarg3;
100144   if (!argp3) {
100145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100146     return ;
100147   }
100148   arg3 = *argp3;
100149   {
100150     try {
100151       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
100152     } catch (std::out_of_range& e) {
100153       {
100154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100155       };
100156     } catch (std::exception& e) {
100157       {
100158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100159       };
100160     } catch (...) {
100161       {
100162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100163       };
100164     }
100165   }
100166 }
100167
100168
100169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
100170   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100171   std::string *arg2 = 0 ;
100172   Dali::Widget::Termination arg3 ;
100173
100174   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100175   if (!jarg2) {
100176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100177     return ;
100178   }
100179   std::string arg2_str(jarg2);
100180   arg2 = &arg2_str;
100181   arg3 = (Dali::Widget::Termination)jarg3;
100182   {
100183     try {
100184       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
100185     } catch (std::out_of_range& e) {
100186       {
100187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100188       };
100189     } catch (std::exception& e) {
100190       {
100191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100192       };
100193     } catch (...) {
100194       {
100195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100196       };
100197     }
100198   }
100199 }
100200
100201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
100202   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100203   std::string *arg2 = 0 ;
100204   Dali::Widget::Termination arg3 ;
100205
100206   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100207   if (!jarg2) {
100208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100209     return ;
100210   }
100211   std::string arg2_str(jarg2);
100212   arg2 = &arg2_str;
100213   arg3 = (Dali::Widget::Termination)jarg3;
100214   {
100215     try {
100216       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
100217     } catch (std::out_of_range& e) {
100218       {
100219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100220       };
100221     } catch (std::exception& e) {
100222       {
100223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100224       };
100225     } catch (...) {
100226       {
100227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100228       };
100229     }
100230   }
100231 }
100232
100233
100234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
100235   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100236
100237   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100238   {
100239     try {
100240       (arg1)->OnPause();
100241     } catch (std::out_of_range& e) {
100242       {
100243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100244       };
100245     } catch (std::exception& e) {
100246       {
100247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100248       };
100249     } catch (...) {
100250       {
100251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100252       };
100253     }
100254   }
100255 }
100256
100257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
100258   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100259
100260   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100261   {
100262     try {
100263       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
100264     } catch (std::out_of_range& e) {
100265       {
100266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100267       };
100268     } catch (std::exception& e) {
100269       {
100270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100271       };
100272     } catch (...) {
100273       {
100274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100275       };
100276     }
100277   }
100278 }
100279
100280
100281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
100282   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100283
100284   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100285   {
100286     try {
100287       (arg1)->OnResume();
100288     } catch (std::out_of_range& e) {
100289       {
100290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100291       };
100292     } catch (std::exception& e) {
100293       {
100294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100295       };
100296     } catch (...) {
100297       {
100298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100299       };
100300     }
100301   }
100302 }
100303
100304
100305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
100306   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100307
100308   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100309   {
100310     try {
100311       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
100312     } catch (std::out_of_range& e) {
100313       {
100314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100315       };
100316     } catch (std::exception& e) {
100317       {
100318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100319       };
100320     } catch (...) {
100321       {
100322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100323       };
100324     }
100325   }
100326 }
100327
100328
100329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
100330   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100331   Dali::Window arg2 ;
100332   Dali::Window *argp2 ;
100333
100334   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100335   argp2 = (Dali::Window *)jarg2;
100336   if (!argp2) {
100337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100338     return ;
100339   }
100340   arg2 = *argp2;
100341   {
100342     try {
100343       (arg1)->OnResize(arg2);
100344     } catch (std::out_of_range& e) {
100345       {
100346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100347       };
100348     } catch (std::exception& e) {
100349       {
100350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100351       };
100352     } catch (...) {
100353       {
100354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100355       };
100356     }
100357   }
100358 }
100359
100360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
100361   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100362   Dali::Window arg2 ;
100363   Dali::Window *argp2 ;
100364
100365   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100366   argp2 = (Dali::Window *)jarg2;
100367   if (!argp2) {
100368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100369     return ;
100370   }
100371   arg2 = *argp2;
100372   {
100373     try {
100374       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
100375     } catch (std::out_of_range& e) {
100376       {
100377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100378       };
100379     } catch (std::exception& e) {
100380       {
100381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100382       };
100383     } catch (...) {
100384       {
100385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100386       };
100387     }
100388   }
100389 }
100390
100391
100392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
100393   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100394   std::string *arg2 = 0 ;
100395   int arg3 ;
100396
100397   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100398   if (!jarg2) {
100399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100400     return ;
100401   }
100402   std::string arg2_str(jarg2);
100403   arg2 = &arg2_str;
100404   arg3 = (int)jarg3;
100405   {
100406     try {
100407       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
100408     } catch (std::out_of_range& e) {
100409       {
100410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100411       };
100412     } catch (std::exception& e) {
100413       {
100414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100415       };
100416     } catch (...) {
100417       {
100418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100419       };
100420     }
100421   }
100422 }
100423
100424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
100425   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100426   std::string *arg2 = 0 ;
100427   int arg3 ;
100428
100429   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100430   if (!jarg2) {
100431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100432     return ;
100433   }
100434   std::string arg2_str(jarg2);
100435   arg2 = &arg2_str;
100436   arg3 = (int)jarg3;
100437   {
100438     try {
100439       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
100440     } catch (std::out_of_range& e) {
100441       {
100442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100443       };
100444     } catch (std::exception& e) {
100445       {
100446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100447       };
100448     } catch (...) {
100449       {
100450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100451       };
100452     }
100453   }
100454 }
100455
100456
100457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
100458   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100459   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100460   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100461
100462   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100463   arg2 = (Dali::SlotObserver *)jarg2;
100464   arg3 = (Dali::CallbackBase *)jarg3;
100465   {
100466     try {
100467       (arg1)->SignalConnected(arg2,arg3);
100468     } catch (std::out_of_range& e) {
100469       {
100470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100471       };
100472     } catch (std::exception& e) {
100473       {
100474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100475       };
100476     } catch (...) {
100477       {
100478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100479       };
100480     }
100481   }
100482 }
100483
100484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
100485   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100486   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100487   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100488
100489   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100490   arg2 = (Dali::SlotObserver *)jarg2;
100491   arg3 = (Dali::CallbackBase *)jarg3;
100492   {
100493     try {
100494       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
100495     } catch (std::out_of_range& e) {
100496       {
100497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100498       };
100499     } catch (std::exception& e) {
100500       {
100501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100502       };
100503     } catch (...) {
100504       {
100505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100506       };
100507     }
100508   }
100509 }
100510
100511
100512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
100513   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100514   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100515   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100516
100517   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100518   arg2 = (Dali::SlotObserver *)jarg2;
100519   arg3 = (Dali::CallbackBase *)jarg3;
100520   {
100521     try {
100522       (arg1)->SignalDisconnected(arg2,arg3);
100523     } catch (std::out_of_range& e) {
100524       {
100525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100526       };
100527     } catch (std::exception& e) {
100528       {
100529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100530       };
100531     } catch (...) {
100532       {
100533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100534       };
100535     }
100536   }
100537 }
100538
100539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
100540   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100541   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100542   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100543
100544   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100545   arg2 = (Dali::SlotObserver *)jarg2;
100546   arg3 = (Dali::CallbackBase *)jarg3;
100547   {
100548     try {
100549       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
100550     } catch (std::out_of_range& e) {
100551       {
100552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100553       };
100554     } catch (std::exception& e) {
100555       {
100556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100557       };
100558     } catch (...) {
100559       {
100560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100561       };
100562     }
100563   }
100564 }
100565
100566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
100567   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100568   std::string *arg2 = 0 ;
100569
100570   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100571   if (!jarg2) {
100572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100573     return ;
100574   }
100575   std::string arg2_str(jarg2);
100576   arg2 = &arg2_str;
100577   {
100578     try {
100579       (arg1)->SetContentInfo((std::string const &)*arg2);
100580     } catch (std::out_of_range& e) {
100581       {
100582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100583       };
100584     } catch (std::exception& e) {
100585       {
100586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100587       };
100588     } catch (...) {
100589       {
100590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100591       };
100592     }
100593   }
100594 }
100595
100596
100597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
100598   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100599   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
100600
100601   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100602   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
100603   {
100604     try {
100605       (arg1)->SetImpl(arg2);
100606     } catch (std::out_of_range& e) {
100607       {
100608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100609       };
100610     } catch (std::exception& e) {
100611       {
100612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100613       };
100614     } catch (...) {
100615       {
100616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100617       };
100618     }
100619   }
100620 }
100621
100622 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) {
100623
100624   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
100625   if (director) {
100626     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
100627   }
100628 }
100629
100630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
100631   void * jresult ;
100632   Dali::Widget *arg1 = 0 ;
100633   SwigDirector_WidgetImpl *result = 0 ;
100634
100635   arg1 = (Dali::Widget *)jarg1;
100636   if (!arg1) {
100637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
100638     return 0;
100639   }
100640   {
100641     try {
100642       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
100643     } catch (std::out_of_range& e) {
100644       {
100645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100646       };
100647     } catch (std::exception& e) {
100648       {
100649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100650       };
100651     } catch (...) {
100652       {
100653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100654       };
100655     }
100656   }
100657
100658   jresult = (void *)result;
100659   return jresult;
100660 }
100661
100662
100663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
100664   void * jresult ;
100665   int *arg1 = (int *) 0 ;
100666   char ***arg2 ;
100667   std::string *arg3 = 0 ;
100668   Dali::WidgetApplication result;
100669   {
100670     int index = 0;
100671     int length = 0;
100672     char *retPtr;
100673     char *nextPtr;
100674     argWidgetC = jarg1;
100675     argWidgetV = new char*[jarg1 + 1];
100676
100677     retPtr = strtok_r( jarg2, " ", &nextPtr);
100678     if( retPtr )
100679     {
100680       length = strlen(retPtr);
100681     }
100682     argWidgetV[index] = new char[length + 1];
100683     if( retPtr )
100684     {
100685       strncpy(argWidgetV[index], retPtr, length);
100686     }
100687     argWidgetV[index][length] = '\0';
100688     index++;
100689
100690     while (index < jarg1)
100691     {
100692       length = 0;
100693       retPtr = strtok_r(NULL, " ", &nextPtr);
100694       if( retPtr )
100695       {
100696         length = strlen(retPtr);
100697       }
100698       argWidgetV[index] = new char[length + 1];
100699       if( retPtr )
100700       {
100701         strncpy(argWidgetV[index], retPtr, length);
100702       }
100703       argWidgetV[index][length] = '\0';
100704       index++;
100705     }
100706
100707     argWidgetV[jarg1] = NULL;
100708     argWidgetC = jarg1;
100709
100710     arg1 = &argWidgetC;
100711     arg2 = &argWidgetV;
100712   }
100713
100714   if (!jarg3) {
100715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100716     return 0;
100717   }
100718   std::string arg3_str(jarg3);
100719   arg3 = &arg3_str;
100720   {
100721     try {
100722       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
100723     } catch (std::out_of_range& e) {
100724       {
100725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100726       };
100727     } catch (std::exception& e) {
100728       {
100729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100730       };
100731     } catch (...) {
100732       {
100733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100734       };
100735     }
100736   }
100737   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
100738
100739   return jresult;
100740 }
100741
100742
100743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
100744   void * jresult ;
100745   Dali::WidgetApplication *result = 0 ;
100746
100747   {
100748     try {
100749       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
100750     } catch (std::out_of_range& e) {
100751       {
100752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100753       };
100754     } catch (std::exception& e) {
100755       {
100756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100757       };
100758     } catch (...) {
100759       {
100760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100761       };
100762     }
100763   }
100764   jresult = (void *)result;
100765   return jresult;
100766 }
100767
100768
100769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
100770   void * jresult ;
100771   Dali::WidgetApplication *arg1 = 0 ;
100772   Dali::WidgetApplication *result = 0 ;
100773
100774   arg1 = (Dali::WidgetApplication *)jarg1;
100775   if (!arg1) {
100776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
100777     return 0;
100778   }
100779   {
100780     try {
100781       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
100782     } catch (std::out_of_range& e) {
100783       {
100784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100785       };
100786     } catch (std::exception& e) {
100787       {
100788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100789       };
100790     } catch (...) {
100791       {
100792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100793       };
100794     }
100795   }
100796   jresult = (void *)result;
100797   return jresult;
100798 }
100799
100800
100801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
100802   void * jresult ;
100803   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
100804   Dali::WidgetApplication *arg2 = 0 ;
100805   Dali::WidgetApplication *result = 0 ;
100806
100807   arg1 = (Dali::WidgetApplication *)jarg1;
100808   arg2 = (Dali::WidgetApplication *)jarg2;
100809   if (!arg2) {
100810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
100811     return 0;
100812   }
100813   {
100814     try {
100815       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
100816     } catch (std::out_of_range& e) {
100817       {
100818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100819       };
100820     } catch (std::exception& e) {
100821       {
100822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100823       };
100824     } catch (...) {
100825       {
100826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100827       };
100828     }
100829   }
100830   jresult = (void *)result;
100831   return jresult;
100832 }
100833
100834
100835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
100836   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
100837
100838   arg1 = (Dali::WidgetApplication *)jarg1;
100839   {
100840     try {
100841       delete arg1;
100842       if( argWidgetV )
100843       {
100844         // free string data
100845         for( int i=0; i < argWidgetC+1; i++)
100846         {
100847           delete [] argWidgetV[i];
100848         }
100849         delete [] argWidgetV;
100850       }
100851     } catch (std::out_of_range& e) {
100852       {
100853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100854       };
100855     } catch (std::exception& e) {
100856       {
100857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100858       };
100859     } catch (...) {
100860       {
100861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100862       };
100863     }
100864   }
100865 }
100866
100867
100868 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
100869 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
100870
100871 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
100872 {
100873   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
100874   return *widget;
100875 }
100876
100877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
100878   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
100879   std::string *arg2 = 0 ;
100880
100881   arg1 = (Dali::WidgetApplication *)jarg1;
100882   if (!jarg2) {
100883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100884     return ;
100885   }
100886   std::string arg2_str(*jarg2);
100887   arg2 = &arg2_str;
100888
100889   if(!_CSharpCreateWidgetFunction)
100890   {
100891     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
100892   }
100893
100894   {
100895     try {
100896       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
100897     } catch (std::out_of_range& e) {
100898       {
100899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100900       };
100901     } catch (std::exception& e) {
100902       {
100903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100904       };
100905     } catch (...) {
100906       {
100907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100908       };
100909     }
100910   }
100911
100912   //Typemap argout in c++ file.
100913   //This will convert c++ string to c# string
100914   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
100915 }
100916
100917
100918 //for PixelBuffer and ImageLoading
100919
100920 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
100921     return (Dali::BaseHandle *)jarg1;
100922 }
100923
100924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
100925   void * jresult ;
100926   unsigned int arg1 ;
100927   unsigned int arg2 ;
100928   Dali::Pixel::Format arg3 ;
100929   Dali::Devel::PixelBuffer result;
100930
100931   arg1 = (unsigned int)jarg1;
100932   arg2 = (unsigned int)jarg2;
100933   arg3 = (Dali::Pixel::Format)jarg3;
100934   {
100935     try {
100936       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
100937     } catch (std::out_of_range& e) {
100938       {
100939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100940       };
100941     } catch (std::exception& e) {
100942       {
100943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100944       };
100945     } catch (...) {
100946       {
100947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100948       };
100949     }
100950   }
100951   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
100952   return jresult;
100953 }
100954
100955
100956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
100957   void * jresult ;
100958   Dali::Devel::PixelBuffer *result = 0 ;
100959
100960   {
100961     try {
100962       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
100963     } catch (std::out_of_range& e) {
100964       {
100965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100966       };
100967     } catch (std::exception& e) {
100968       {
100969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100970       };
100971     } catch (...) {
100972       {
100973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100974       };
100975     }
100976   }
100977   jresult = (void *)result;
100978   return jresult;
100979 }
100980
100981
100982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
100983   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
100984
100985   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100986   {
100987     try {
100988       delete arg1;
100989     } catch (std::out_of_range& e) {
100990       {
100991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100992       };
100993     } catch (std::exception& e) {
100994       {
100995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100996       };
100997     } catch (...) {
100998       {
100999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101000       };
101001     }
101002   }
101003 }
101004
101005
101006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
101007   void * jresult ;
101008   Dali::Devel::PixelBuffer *arg1 = 0 ;
101009   Dali::Devel::PixelBuffer *result = 0 ;
101010
101011   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101012   if (!arg1) {
101013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
101014     return 0;
101015   }
101016   {
101017     try {
101018       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
101019     } catch (std::out_of_range& e) {
101020       {
101021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101022       };
101023     } catch (std::exception& e) {
101024       {
101025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101026       };
101027     } catch (...) {
101028       {
101029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101030       };
101031     }
101032   }
101033   jresult = (void *)result;
101034   return jresult;
101035 }
101036
101037
101038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
101039   void * jresult ;
101040   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101041   Dali::Devel::PixelBuffer *arg2 = 0 ;
101042   Dali::Devel::PixelBuffer *result = 0 ;
101043
101044   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101045   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
101046   if (!arg2) {
101047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
101048     return 0;
101049   }
101050   {
101051     try {
101052       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
101053     } catch (std::out_of_range& e) {
101054       {
101055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101056       };
101057     } catch (std::exception& e) {
101058       {
101059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101060       };
101061     } catch (...) {
101062       {
101063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101064       };
101065     }
101066   }
101067   jresult = (void *)result;
101068   return jresult;
101069 }
101070
101071
101072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
101073   void * jresult ;
101074   Dali::Devel::PixelBuffer *arg1 = 0 ;
101075   Dali::PixelData result;
101076
101077   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101078   if (!arg1) {
101079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
101080     return 0;
101081   }
101082   {
101083     try {
101084       result = Dali::Devel::PixelBuffer::Convert(*arg1);
101085     } catch (std::out_of_range& e) {
101086       {
101087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101088       };
101089     } catch (std::exception& e) {
101090       {
101091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101092       };
101093     } catch (...) {
101094       {
101095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101096       };
101097     }
101098   }
101099   jresult = new Dali::PixelData((const Dali::PixelData &)result);
101100   return jresult;
101101 }
101102
101103
101104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
101105   void * jresult ;
101106   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101107   Dali::PixelData result;
101108
101109   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101110   {
101111     try {
101112       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
101113     } catch (std::out_of_range& e) {
101114       {
101115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101116       };
101117     } catch (std::exception& e) {
101118       {
101119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101120       };
101121     } catch (...) {
101122       {
101123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101124       };
101125     }
101126   }
101127   jresult = new Dali::PixelData((const Dali::PixelData &)result);
101128   return jresult;
101129 }
101130
101131
101132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
101133   void * jresult ;
101134   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101135   unsigned char *result = 0 ;
101136
101137   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101138   {
101139     try {
101140       result = (unsigned char *)(arg1)->GetBuffer();
101141     } catch (std::out_of_range& e) {
101142       {
101143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101144       };
101145     } catch (std::exception& e) {
101146       {
101147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101148       };
101149     } catch (...) {
101150       {
101151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101152       };
101153     }
101154   }
101155   jresult = (void *)result;
101156   return jresult;
101157 }
101158
101159
101160 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
101161   unsigned int jresult ;
101162   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101163   unsigned int result;
101164
101165   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101166   {
101167     try {
101168       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
101169     } catch (std::out_of_range& e) {
101170       {
101171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101172       };
101173     } catch (std::exception& e) {
101174       {
101175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101176       };
101177     } catch (...) {
101178       {
101179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101180       };
101181     }
101182   }
101183   jresult = result;
101184   return jresult;
101185 }
101186
101187
101188 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
101189   unsigned int jresult ;
101190   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101191   unsigned int result;
101192
101193   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101194   {
101195     try {
101196       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
101197     } catch (std::out_of_range& e) {
101198       {
101199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101200       };
101201     } catch (std::exception& e) {
101202       {
101203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101204       };
101205     } catch (...) {
101206       {
101207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101208       };
101209     }
101210   }
101211   jresult = result;
101212   return jresult;
101213 }
101214
101215
101216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
101217   int jresult ;
101218   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101219   Dali::Pixel::Format result;
101220
101221   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101222   {
101223     try {
101224       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
101225     } catch (std::out_of_range& e) {
101226       {
101227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101228       };
101229     } catch (std::exception& e) {
101230       {
101231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101232       };
101233     } catch (...) {
101234       {
101235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101236       };
101237     }
101238   }
101239   jresult = (int)result;
101240   return jresult;
101241 }
101242
101243
101244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
101245   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101246   Dali::Devel::PixelBuffer arg2 ;
101247   float arg3 ;
101248   bool arg4 ;
101249   Dali::Devel::PixelBuffer *argp2 ;
101250
101251   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101252   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
101253   if (!argp2) {
101254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
101255     return ;
101256   }
101257   arg2 = *argp2;
101258   arg3 = (float)jarg3;
101259   arg4 = jarg4 ? true : false;
101260   {
101261     try {
101262       (arg1)->ApplyMask(arg2,arg3,arg4);
101263     } catch (std::out_of_range& e) {
101264       {
101265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101266       };
101267     } catch (std::exception& e) {
101268       {
101269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101270       };
101271     } catch (...) {
101272       {
101273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101274       };
101275     }
101276   }
101277 }
101278
101279
101280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
101281   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101282   Dali::Devel::PixelBuffer arg2 ;
101283   float arg3 ;
101284   Dali::Devel::PixelBuffer *argp2 ;
101285
101286   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101287   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
101288   if (!argp2) {
101289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
101290     return ;
101291   }
101292   arg2 = *argp2;
101293   arg3 = (float)jarg3;
101294   {
101295     try {
101296       (arg1)->ApplyMask(arg2,arg3);
101297     } catch (std::out_of_range& e) {
101298       {
101299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101300       };
101301     } catch (std::exception& e) {
101302       {
101303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101304       };
101305     } catch (...) {
101306       {
101307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101308       };
101309     }
101310   }
101311 }
101312
101313
101314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
101315   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101316   Dali::Devel::PixelBuffer arg2 ;
101317   Dali::Devel::PixelBuffer *argp2 ;
101318
101319   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101320   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
101321   if (!argp2) {
101322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
101323     return ;
101324   }
101325   arg2 = *argp2;
101326   {
101327     try {
101328       (arg1)->ApplyMask(arg2);
101329     } catch (std::out_of_range& e) {
101330       {
101331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101332       };
101333     } catch (std::exception& e) {
101334       {
101335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101336       };
101337     } catch (...) {
101338       {
101339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101340       };
101341     }
101342   }
101343 }
101344
101345
101346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
101347   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101348   float arg2 ;
101349
101350   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101351   arg2 = (float)jarg2;
101352   {
101353     try {
101354       (arg1)->ApplyGaussianBlur(arg2);
101355     } catch (std::out_of_range& e) {
101356       {
101357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101358       };
101359     } catch (std::exception& e) {
101360       {
101361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101362       };
101363     } catch (...) {
101364       {
101365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101366       };
101367     }
101368   }
101369 }
101370
101371
101372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
101373   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101374   uint16_t arg2 ;
101375   uint16_t arg3 ;
101376   uint16_t arg4 ;
101377   uint16_t arg5 ;
101378
101379   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101380   arg2 = (uint16_t)jarg2;
101381   arg3 = (uint16_t)jarg3;
101382   arg4 = (uint16_t)jarg4;
101383   arg5 = (uint16_t)jarg5;
101384   {
101385     try {
101386       (arg1)->Crop(arg2,arg3,arg4,arg5);
101387     } catch (std::out_of_range& e) {
101388       {
101389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101390       };
101391     } catch (std::exception& e) {
101392       {
101393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101394       };
101395     } catch (...) {
101396       {
101397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101398       };
101399     }
101400   }
101401 }
101402
101403
101404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
101405   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101406   uint16_t arg2 ;
101407   uint16_t arg3 ;
101408
101409   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101410   arg2 = (uint16_t)jarg2;
101411   arg3 = (uint16_t)jarg3;
101412   {
101413     try {
101414       (arg1)->Resize(arg2,arg3);
101415     } catch (std::out_of_range& e) {
101416       {
101417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101418       };
101419     } catch (std::exception& e) {
101420       {
101421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101422       };
101423     } catch (...) {
101424       {
101425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101426       };
101427     }
101428   }
101429 }
101430
101431
101432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
101433   void * jresult ;
101434   std::string *arg1 = 0 ;
101435   Dali::ImageDimensions arg2 ;
101436   Dali::FittingMode::Type arg3 ;
101437   Dali::SamplingMode::Type arg4 ;
101438   bool arg5 ;
101439   Dali::ImageDimensions *argp2 ;
101440   Dali::Devel::PixelBuffer result;
101441
101442   if (!jarg1) {
101443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101444     return 0;
101445   }
101446   std::string arg1_str(jarg1);
101447   arg1 = &arg1_str;
101448   argp2 = (Dali::ImageDimensions *)jarg2;
101449   if (!argp2) {
101450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101451     return 0;
101452   }
101453   arg2 = *argp2;
101454   arg3 = (Dali::FittingMode::Type)jarg3;
101455   arg4 = (Dali::SamplingMode::Type)jarg4;
101456   arg5 = jarg5 ? true : false;
101457   {
101458     try {
101459       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
101460     } catch (std::out_of_range& e) {
101461       {
101462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101463       };
101464     } catch (std::exception& e) {
101465       {
101466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101467       };
101468     } catch (...) {
101469       {
101470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101471       };
101472     }
101473   }
101474   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101475
101476   return jresult;
101477 }
101478
101479
101480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
101481   void * jresult ;
101482   std::string *arg1 = 0 ;
101483   Dali::ImageDimensions arg2 ;
101484   Dali::FittingMode::Type arg3 ;
101485   Dali::SamplingMode::Type arg4 ;
101486   Dali::ImageDimensions *argp2 ;
101487   Dali::Devel::PixelBuffer result;
101488
101489   if (!jarg1) {
101490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101491     return 0;
101492   }
101493   std::string arg1_str(jarg1);
101494   arg1 = &arg1_str;
101495   argp2 = (Dali::ImageDimensions *)jarg2;
101496   if (!argp2) {
101497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101498     return 0;
101499   }
101500   arg2 = *argp2;
101501   arg3 = (Dali::FittingMode::Type)jarg3;
101502   arg4 = (Dali::SamplingMode::Type)jarg4;
101503   {
101504     try {
101505       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
101506     } catch (std::out_of_range& e) {
101507       {
101508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101509       };
101510     } catch (std::exception& e) {
101511       {
101512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101513       };
101514     } catch (...) {
101515       {
101516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101517       };
101518     }
101519   }
101520   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101521
101522   return jresult;
101523 }
101524
101525
101526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
101527   void * jresult ;
101528   std::string *arg1 = 0 ;
101529   Dali::ImageDimensions arg2 ;
101530   Dali::FittingMode::Type arg3 ;
101531   Dali::ImageDimensions *argp2 ;
101532   Dali::Devel::PixelBuffer result;
101533
101534   if (!jarg1) {
101535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101536     return 0;
101537   }
101538   std::string arg1_str(jarg1);
101539   arg1 = &arg1_str;
101540   argp2 = (Dali::ImageDimensions *)jarg2;
101541   if (!argp2) {
101542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101543     return 0;
101544   }
101545   arg2 = *argp2;
101546   arg3 = (Dali::FittingMode::Type)jarg3;
101547   {
101548     try {
101549       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
101550     } catch (std::out_of_range& e) {
101551       {
101552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101553       };
101554     } catch (std::exception& e) {
101555       {
101556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101557       };
101558     } catch (...) {
101559       {
101560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101561       };
101562     }
101563   }
101564   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101565
101566   return jresult;
101567 }
101568
101569
101570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
101571   void * jresult ;
101572   std::string *arg1 = 0 ;
101573   Dali::ImageDimensions arg2 ;
101574   Dali::ImageDimensions *argp2 ;
101575   Dali::Devel::PixelBuffer result;
101576
101577   if (!jarg1) {
101578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101579     return 0;
101580   }
101581   std::string arg1_str(jarg1);
101582   arg1 = &arg1_str;
101583   argp2 = (Dali::ImageDimensions *)jarg2;
101584   if (!argp2) {
101585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101586     return 0;
101587   }
101588   arg2 = *argp2;
101589   {
101590     try {
101591       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
101592     } catch (std::out_of_range& e) {
101593       {
101594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101595       };
101596     } catch (std::exception& e) {
101597       {
101598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101599       };
101600     } catch (...) {
101601       {
101602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101603       };
101604     }
101605   }
101606   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101607
101608   return jresult;
101609 }
101610
101611
101612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
101613   void * jresult ;
101614   std::string *arg1 = 0 ;
101615   Dali::Devel::PixelBuffer result;
101616
101617   if (!jarg1) {
101618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101619     return 0;
101620   }
101621   std::string arg1_str(jarg1);
101622   arg1 = &arg1_str;
101623   {
101624     try {
101625       result = Dali::LoadImageFromFile((std::string const &)*arg1);
101626     } catch (std::out_of_range& e) {
101627       {
101628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101629       };
101630     } catch (std::exception& e) {
101631       {
101632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101633       };
101634     } catch (...) {
101635       {
101636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101637       };
101638     }
101639   }
101640   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101641
101642   return jresult;
101643 }
101644
101645
101646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
101647   void * jresult ;
101648   std::string *arg1 = 0 ;
101649   Dali::ImageDimensions arg2 ;
101650   Dali::FittingMode::Type arg3 ;
101651   Dali::SamplingMode::Type arg4 ;
101652   bool arg5 ;
101653   Dali::ImageDimensions *argp2 ;
101654   Dali::ImageDimensions result;
101655
101656   if (!jarg1) {
101657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101658     return 0;
101659   }
101660   std::string arg1_str(jarg1);
101661   arg1 = &arg1_str;
101662   argp2 = (Dali::ImageDimensions *)jarg2;
101663   if (!argp2) {
101664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101665     return 0;
101666   }
101667   arg2 = *argp2;
101668   arg3 = (Dali::FittingMode::Type)jarg3;
101669   arg4 = (Dali::SamplingMode::Type)jarg4;
101670   arg5 = jarg5 ? true : false;
101671   {
101672     try {
101673       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
101674     } catch (std::out_of_range& e) {
101675       {
101676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101677       };
101678     } catch (std::exception& e) {
101679       {
101680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101681       };
101682     } catch (...) {
101683       {
101684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101685       };
101686     }
101687   }
101688   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101689
101690   return jresult;
101691 }
101692
101693
101694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
101695   void * jresult ;
101696   std::string *arg1 = 0 ;
101697   Dali::ImageDimensions arg2 ;
101698   Dali::FittingMode::Type arg3 ;
101699   Dali::SamplingMode::Type arg4 ;
101700   Dali::ImageDimensions *argp2 ;
101701   Dali::ImageDimensions result;
101702
101703   if (!jarg1) {
101704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101705     return 0;
101706   }
101707   std::string arg1_str(jarg1);
101708   arg1 = &arg1_str;
101709   argp2 = (Dali::ImageDimensions *)jarg2;
101710   if (!argp2) {
101711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101712     return 0;
101713   }
101714   arg2 = *argp2;
101715   arg3 = (Dali::FittingMode::Type)jarg3;
101716   arg4 = (Dali::SamplingMode::Type)jarg4;
101717   {
101718     try {
101719       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
101720     } catch (std::out_of_range& e) {
101721       {
101722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101723       };
101724     } catch (std::exception& e) {
101725       {
101726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101727       };
101728     } catch (...) {
101729       {
101730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101731       };
101732     }
101733   }
101734   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101735
101736   return jresult;
101737 }
101738
101739
101740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
101741   void * jresult ;
101742   std::string *arg1 = 0 ;
101743   Dali::ImageDimensions arg2 ;
101744   Dali::FittingMode::Type arg3 ;
101745   Dali::ImageDimensions *argp2 ;
101746   Dali::ImageDimensions result;
101747
101748   if (!jarg1) {
101749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101750     return 0;
101751   }
101752   std::string arg1_str(jarg1);
101753   arg1 = &arg1_str;
101754   argp2 = (Dali::ImageDimensions *)jarg2;
101755   if (!argp2) {
101756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101757     return 0;
101758   }
101759   arg2 = *argp2;
101760   arg3 = (Dali::FittingMode::Type)jarg3;
101761   {
101762     try {
101763       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
101764     } catch (std::out_of_range& e) {
101765       {
101766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101767       };
101768     } catch (std::exception& e) {
101769       {
101770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101771       };
101772     } catch (...) {
101773       {
101774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101775       };
101776     }
101777   }
101778   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101779
101780   return jresult;
101781 }
101782
101783
101784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
101785   void * jresult ;
101786   std::string *arg1 = 0 ;
101787   Dali::ImageDimensions arg2 ;
101788   Dali::ImageDimensions *argp2 ;
101789   Dali::ImageDimensions result;
101790
101791   if (!jarg1) {
101792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101793     return 0;
101794   }
101795   std::string arg1_str(jarg1);
101796   arg1 = &arg1_str;
101797   argp2 = (Dali::ImageDimensions *)jarg2;
101798   if (!argp2) {
101799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101800     return 0;
101801   }
101802   arg2 = *argp2;
101803   {
101804     try {
101805       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
101806     } catch (std::out_of_range& e) {
101807       {
101808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101809       };
101810     } catch (std::exception& e) {
101811       {
101812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101813       };
101814     } catch (...) {
101815       {
101816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101817       };
101818     }
101819   }
101820   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101821
101822   return jresult;
101823 }
101824
101825
101826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
101827   void * jresult ;
101828   std::string *arg1 = 0 ;
101829   Dali::ImageDimensions result;
101830
101831   if (!jarg1) {
101832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101833     return 0;
101834   }
101835   std::string arg1_str(jarg1);
101836   arg1 = &arg1_str;
101837   {
101838     try {
101839       result = Dali::GetClosestImageSize((std::string const &)*arg1);
101840     } catch (std::out_of_range& e) {
101841       {
101842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101843       };
101844     } catch (std::exception& e) {
101845       {
101846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101847       };
101848     } catch (...) {
101849       {
101850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101851       };
101852     }
101853   }
101854   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101855
101856   return jresult;
101857 }
101858
101859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
101860   void * jresult ;
101861   std::string *arg1 = 0 ;
101862   Dali::ImageDimensions result;
101863
101864   if (!jarg1) {
101865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101866     return 0;
101867   }
101868   std::string arg1_str(jarg1);
101869   arg1 = &arg1_str;
101870   {
101871     try {
101872       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
101873     } catch (std::out_of_range& e) {
101874       {
101875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101876       };
101877     } catch (std::exception& e) {
101878       {
101879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101880       };
101881     } catch (...) {
101882       {
101883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101884       };
101885     }
101886   }
101887   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101888
101889   return jresult;
101890 }
101891
101892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
101893   void * jresult ;
101894   std::string *arg1 = 0 ;
101895   Dali::ImageDimensions arg2 ;
101896   Dali::FittingMode::Type arg3 ;
101897   Dali::SamplingMode::Type arg4 ;
101898   bool arg5 ;
101899   Dali::ImageDimensions *argp2 ;
101900   Dali::Devel::PixelBuffer result;
101901
101902   if (!jarg1) {
101903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101904     return 0;
101905   }
101906   std::string arg1_str(jarg1);
101907   arg1 = &arg1_str;
101908   argp2 = (Dali::ImageDimensions *)jarg2;
101909   if (!argp2) {
101910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101911     return 0;
101912   }
101913   arg2 = *argp2;
101914   arg3 = (Dali::FittingMode::Type)jarg3;
101915   arg4 = (Dali::SamplingMode::Type)jarg4;
101916   arg5 = jarg5 ? true : false;
101917   {
101918     try {
101919       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
101920     } catch (std::out_of_range& e) {
101921       {
101922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101923       };
101924     } catch (std::exception& e) {
101925       {
101926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101927       };
101928     } catch (...) {
101929       {
101930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101931       };
101932     }
101933   }
101934   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101935
101936   return jresult;
101937 }
101938
101939
101940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
101941   void * jresult ;
101942   std::string *arg1 = 0 ;
101943   Dali::ImageDimensions arg2 ;
101944   Dali::FittingMode::Type arg3 ;
101945   Dali::SamplingMode::Type arg4 ;
101946   Dali::ImageDimensions *argp2 ;
101947   Dali::Devel::PixelBuffer result;
101948
101949   if (!jarg1) {
101950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101951     return 0;
101952   }
101953   std::string arg1_str(jarg1);
101954   arg1 = &arg1_str;
101955   argp2 = (Dali::ImageDimensions *)jarg2;
101956   if (!argp2) {
101957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101958     return 0;
101959   }
101960   arg2 = *argp2;
101961   arg3 = (Dali::FittingMode::Type)jarg3;
101962   arg4 = (Dali::SamplingMode::Type)jarg4;
101963   {
101964     try {
101965       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
101966     } catch (std::out_of_range& e) {
101967       {
101968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101969       };
101970     } catch (std::exception& e) {
101971       {
101972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101973       };
101974     } catch (...) {
101975       {
101976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101977       };
101978     }
101979   }
101980   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101981
101982   return jresult;
101983 }
101984
101985
101986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
101987   void * jresult ;
101988   std::string *arg1 = 0 ;
101989   Dali::ImageDimensions arg2 ;
101990   Dali::FittingMode::Type arg3 ;
101991   Dali::ImageDimensions *argp2 ;
101992   Dali::Devel::PixelBuffer result;
101993
101994   if (!jarg1) {
101995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101996     return 0;
101997   }
101998   std::string arg1_str(jarg1);
101999   arg1 = &arg1_str;
102000   argp2 = (Dali::ImageDimensions *)jarg2;
102001   if (!argp2) {
102002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102003     return 0;
102004   }
102005   arg2 = *argp2;
102006   arg3 = (Dali::FittingMode::Type)jarg3;
102007   {
102008     try {
102009       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
102010     } catch (std::out_of_range& e) {
102011       {
102012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102013       };
102014     } catch (std::exception& e) {
102015       {
102016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102017       };
102018     } catch (...) {
102019       {
102020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102021       };
102022     }
102023   }
102024   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102025
102026   return jresult;
102027 }
102028
102029
102030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
102031   void * jresult ;
102032   std::string *arg1 = 0 ;
102033   Dali::ImageDimensions arg2 ;
102034   Dali::ImageDimensions *argp2 ;
102035   Dali::Devel::PixelBuffer result;
102036
102037   if (!jarg1) {
102038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102039     return 0;
102040   }
102041   std::string arg1_str(jarg1);
102042   arg1 = &arg1_str;
102043   argp2 = (Dali::ImageDimensions *)jarg2;
102044   if (!argp2) {
102045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102046     return 0;
102047   }
102048   arg2 = *argp2;
102049   {
102050     try {
102051       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
102052     } catch (std::out_of_range& e) {
102053       {
102054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102055       };
102056     } catch (std::exception& e) {
102057       {
102058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102059       };
102060     } catch (...) {
102061       {
102062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102063       };
102064     }
102065   }
102066   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102067
102068   return jresult;
102069 }
102070
102071
102072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
102073   void * jresult ;
102074   std::string *arg1 = 0 ;
102075   Dali::Devel::PixelBuffer result;
102076
102077   if (!jarg1) {
102078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102079     return 0;
102080   }
102081   std::string arg1_str(jarg1);
102082   arg1 = &arg1_str;
102083   {
102084     try {
102085       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
102086     } catch (std::out_of_range& e) {
102087       {
102088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102089       };
102090     } catch (std::exception& e) {
102091       {
102092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102093       };
102094     } catch (...) {
102095       {
102096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102097       };
102098     }
102099   }
102100   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102101
102102   return jresult;
102103 }
102104
102105
102106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
102107   void * jresult ;
102108   Dali::Toolkit::WebView result;
102109
102110   {
102111     try {
102112       result = Dali::Toolkit::WebView::New();
102113     } catch (std::out_of_range& e) {
102114       {
102115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102116       };
102117     } catch (std::exception& e) {
102118       {
102119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102120       };
102121     } catch (Dali::DaliException e) {
102122       {
102123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102124       };
102125     } catch (...) {
102126       {
102127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102128       };
102129     }
102130   }
102131   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
102132   return jresult;
102133 }
102134
102135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
102136   void * jresult ;
102137   Dali::Toolkit::WebView result;
102138
102139   std::string *arg1;
102140   std::string *arg2;
102141
102142   if (!jarg1) {
102143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
102144     return 0;
102145   }
102146   if (!jarg2) {
102147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
102148     return 0;
102149   }
102150
102151   std::string jarg1_str = std::string(jarg1);
102152   std::string jarg2_str = std::string(jarg2);
102153
102154   arg1 = &jarg1_str;
102155   arg2 = &jarg2_str;
102156
102157   {
102158     try {
102159       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
102160     } catch (std::out_of_range& e) {
102161       {
102162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102163       };
102164     } catch (std::exception& e) {
102165       {
102166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102167       };
102168     } catch (Dali::DaliException e) {
102169       {
102170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102171       };
102172     } catch (...) {
102173       {
102174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102175       };
102176     }
102177   }
102178   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
102179   return jresult;
102180 }
102181
102182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
102183   void * jresult ;
102184   Dali::Toolkit::WebView *arg1 = 0 ;
102185   Dali::Toolkit::WebView *result = 0 ;
102186
102187   arg1 = (Dali::Toolkit::WebView *)jarg1;
102188   if (!arg1) {
102189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
102190     return 0;
102191   }
102192   {
102193     try {
102194       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
102195     } catch (std::out_of_range& e) {
102196       {
102197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102198       };
102199     } catch (std::exception& e) {
102200       {
102201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102202       };
102203     } catch (Dali::DaliException e) {
102204       {
102205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102206       };
102207     } catch (...) {
102208       {
102209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102210       };
102211     }
102212   }
102213   jresult = (void *)result;
102214   return jresult;
102215 }
102216
102217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
102218   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102219   arg1 = (Dali::Toolkit::WebView *)jarg1;
102220   {
102221     try {
102222       delete arg1;
102223     } catch (std::out_of_range& e) {
102224       {
102225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102226       };
102227     } catch (std::exception& e) {
102228       {
102229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102230       };
102231     } catch (Dali::DaliException e) {
102232       {
102233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102234       };
102235     } catch (...) {
102236       {
102237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102238       };
102239     }
102240   }
102241 }
102242
102243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
102244   void * jresult ;
102245   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102246   Dali::Toolkit::WebView *arg2 = 0 ;
102247   Dali::Toolkit::WebView *result = 0 ;
102248
102249   arg1 = (Dali::Toolkit::WebView *)jarg1;
102250   arg2 = (Dali::Toolkit::WebView *)jarg2;
102251   if (!arg2) {
102252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
102253     return 0;
102254   }
102255   {
102256     try {
102257       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
102258     } catch (std::out_of_range& e) {
102259       {
102260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102261       };
102262     } catch (std::exception& e) {
102263       {
102264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102265       };
102266     } catch (Dali::DaliException e) {
102267       {
102268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102269       };
102270     } catch (...) {
102271       {
102272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102273       };
102274     }
102275   }
102276   jresult = (void *)result;
102277   return jresult;
102278 }
102279
102280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
102281   void * jresult ;
102282   Dali::BaseHandle arg1 ;
102283   Dali::BaseHandle *argp1 ;
102284   Dali::Toolkit::WebView result;
102285
102286   argp1 = (Dali::BaseHandle *)jarg1;
102287   if (!argp1) {
102288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
102289     return 0;
102290   }
102291   arg1 = *argp1;
102292   {
102293     try {
102294       result = Dali::Toolkit::WebView::DownCast(arg1);
102295     } catch (std::out_of_range& e) {
102296       {
102297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102298       };
102299     } catch (std::exception& e) {
102300       {
102301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102302       };
102303     } catch (Dali::DaliException e) {
102304       {
102305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102306       };
102307     } catch (...) {
102308       {
102309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102310       };
102311     }
102312   }
102313   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
102314   return jresult;
102315 }
102316
102317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
102318   return (int) Dali::Toolkit::WebView::Property::URL;
102319 }
102320
102321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
102322   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
102323 }
102324
102325 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
102326   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
102327 }
102328
102329 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
102330   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
102331 }
102332
102333 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
102334   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
102335 }
102336
102337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
102338   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
102339 }
102340
102341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
102342   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
102343 }
102344
102345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
102346   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
102347 }
102348
102349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
102350   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102351   std::string *arg2;
102352
102353   arg1 = (Dali::Toolkit::WebView *)jarg1;
102354
102355   if (!jarg2) {
102356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102357     return;
102358   }
102359
102360   std::string jarg2str = std::string(jarg2);
102361   arg2 = &jarg2str;
102362   {
102363     try {
102364       (arg1)->LoadUrl((std::string const &)*arg2);
102365     } catch (std::out_of_range& e) {
102366       {
102367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102368       };
102369     } catch (std::exception& e) {
102370       {
102371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102372       };
102373     } catch (Dali::DaliException e) {
102374       {
102375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102376       };
102377     } catch (...) {
102378       {
102379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102380       };
102381     }
102382   }
102383 }
102384
102385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
102386   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102387   std::string *arg2;
102388
102389   arg1 = (Dali::Toolkit::WebView *)jarg1;
102390   if (!jarg2) {
102391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102392     return;
102393   }
102394   std::string jarg2str = std::string(jarg2);
102395   arg2 = &jarg2str;
102396   {
102397     try {
102398       (arg1)->LoadHTMLString((std::string const &)*arg2);
102399     } catch (std::out_of_range& e) {
102400       {
102401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102402       };
102403     } catch (std::exception& e) {
102404       {
102405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102406       };
102407     } catch (Dali::DaliException e) {
102408       {
102409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102410       };
102411     } catch (...) {
102412       {
102413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102414       };
102415     }
102416   }
102417 }
102418
102419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
102420   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102421
102422   arg1 = (Dali::Toolkit::WebView *)jarg1;
102423   {
102424     try {
102425       (arg1)->Reload();
102426     } catch (std::out_of_range& e) {
102427       {
102428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102429       };
102430     } catch (std::exception& e) {
102431       {
102432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102433       };
102434     } catch (Dali::DaliException e) {
102435       {
102436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102437       };
102438     } catch (...) {
102439       {
102440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102441       };
102442     }
102443   }
102444 }
102445
102446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
102447   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102448
102449   arg1 = (Dali::Toolkit::WebView *)jarg1;
102450   {
102451     try {
102452       (arg1)->StopLoading();
102453     } catch (std::out_of_range& e) {
102454       {
102455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102456       };
102457     } catch (std::exception& e) {
102458       {
102459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102460       };
102461     } catch (Dali::DaliException e) {
102462       {
102463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102464       };
102465     } catch (...) {
102466       {
102467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102468       };
102469     }
102470   }
102471 }
102472
102473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
102474   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102475
102476   arg1 = (Dali::Toolkit::WebView *)jarg1;
102477   {
102478     try {
102479       (arg1)->Suspend();
102480     } catch (std::out_of_range& e) {
102481       {
102482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102483       };
102484     } catch (std::exception& e) {
102485       {
102486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102487       };
102488     } catch (Dali::DaliException e) {
102489       {
102490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102491       };
102492     } catch (...) {
102493       {
102494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102495       };
102496     }
102497   }
102498 }
102499
102500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
102501   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102502
102503   arg1 = (Dali::Toolkit::WebView *)jarg1;
102504   {
102505     try {
102506       (arg1)->Resume();
102507     } catch (std::out_of_range& e) {
102508       {
102509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102510       };
102511     } catch (std::exception& e) {
102512       {
102513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102514       };
102515     } catch (Dali::DaliException e) {
102516       {
102517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102518       };
102519     } catch (...) {
102520       {
102521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102522       };
102523     }
102524   }
102525 }
102526
102527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
102528   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102529
102530   arg1 = (Dali::Toolkit::WebView *)jarg1;
102531   {
102532     try {
102533       (arg1)->GoBack();
102534     } catch (std::out_of_range& e) {
102535       {
102536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102537       };
102538     } catch (std::exception& e) {
102539       {
102540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102541       };
102542     } catch (Dali::DaliException e) {
102543       {
102544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102545       };
102546     } catch (...) {
102547       {
102548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102549       };
102550     }
102551   }
102552 }
102553
102554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
102555   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102556
102557   arg1 = (Dali::Toolkit::WebView *)jarg1;
102558   {
102559     try {
102560       (arg1)->GoForward();
102561     } catch (std::out_of_range& e) {
102562       {
102563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102564       };
102565     } catch (std::exception& e) {
102566       {
102567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102568       };
102569     } catch (Dali::DaliException e) {
102570       {
102571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102572       };
102573     } catch (...) {
102574       {
102575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102576       };
102577     }
102578   }
102579 }
102580
102581 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
102582   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102583   bool ret;
102584
102585   arg1 = (Dali::Toolkit::WebView *)jarg1;
102586   {
102587     try {
102588       ret = (arg1)->CanGoBack();
102589     } catch (std::out_of_range& e) {
102590       {
102591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
102592       };
102593     } catch (std::exception& e) {
102594       {
102595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
102596       };
102597     } catch (Dali::DaliException e) {
102598       {
102599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
102600       };
102601     } catch (...) {
102602       {
102603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
102604       };
102605     }
102606   }
102607   return ret;
102608 }
102609
102610 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
102611   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102612   bool ret;
102613
102614   arg1 = (Dali::Toolkit::WebView *)jarg1;
102615   {
102616     try {
102617       ret = (arg1)->CanGoForward();
102618     } catch (std::out_of_range& e) {
102619       {
102620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
102621       };
102622     } catch (std::exception& e) {
102623       {
102624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
102625       };
102626     } catch (Dali::DaliException e) {
102627       {
102628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
102629       };
102630     } catch (...) {
102631       {
102632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
102633       };
102634     }
102635   }
102636   return ret;
102637 }
102638
102639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
102640   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102641   std::string *arg2;
102642
102643   arg1 = (Dali::Toolkit::WebView *)jarg1;
102644   if (!jarg2) {
102645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102646     return;
102647   }
102648   std::string jarg2_str = std::string(jarg2);
102649   arg2 = &jarg2_str;
102650
102651   {
102652     try {
102653       if (jarg3) {
102654         void (*handler)(char*) = (void (*)(char*)) jarg3;
102655         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
102656           handler(SWIG_csharp_string_callback(result.c_str()));
102657         });
102658       } else {
102659         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
102660       }
102661     } catch (std::out_of_range& e) {
102662       {
102663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102664       };
102665     } catch (std::exception& e) {
102666       {
102667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102668       };
102669     } catch (Dali::DaliException e) {
102670       {
102671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102672       };
102673     } catch (...) {
102674       {
102675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102676       };
102677     }
102678   }
102679 }
102680
102681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
102682 {
102683   if (!jarg2) {
102684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102685     return;
102686   }
102687
102688   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
102689   std::string exposedObjectName = jarg2;
102690   void (*handler)(char*) = (void (*)(char*)) jarg3;
102691
102692   {
102693     try {
102694       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
102695         handler(SWIG_csharp_string_callback(message.c_str()));
102696       });
102697     } catch (std::out_of_range& e) {
102698       {
102699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102700       };
102701     } catch (std::exception& e) {
102702       {
102703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102704       };
102705     } catch (Dali::DaliException e) {
102706       {
102707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102708       };
102709     } catch (...) {
102710       {
102711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102712       };
102713     }
102714   }
102715 }
102716
102717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
102718   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102719
102720   arg1 = (Dali::Toolkit::WebView *)jarg1;
102721   {
102722     try {
102723       (arg1)->ClearHistory();
102724     } catch (std::out_of_range& e) {
102725       {
102726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102727       };
102728     } catch (std::exception& e) {
102729       {
102730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102731       };
102732     } catch (Dali::DaliException e) {
102733       {
102734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102735       };
102736     } catch (...) {
102737       {
102738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102739       };
102740     }
102741   }
102742 }
102743
102744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
102745   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102746
102747   arg1 = (Dali::Toolkit::WebView *)jarg1;
102748   {
102749     try {
102750       (arg1)->ClearCache();
102751     } catch (std::out_of_range& e) {
102752       {
102753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102754       };
102755     } catch (std::exception& e) {
102756       {
102757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102758       };
102759     } catch (Dali::DaliException e) {
102760       {
102761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102762       };
102763     } catch (...) {
102764       {
102765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102766       };
102767     }
102768   }
102769 }
102770
102771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
102772   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102773
102774   arg1 = (Dali::Toolkit::WebView *)jarg1;
102775   {
102776     try {
102777       (arg1)->ClearCookies();
102778     } catch (std::out_of_range& e) {
102779       {
102780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102781       };
102782     } catch (std::exception& e) {
102783       {
102784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102785       };
102786     } catch (Dali::DaliException e) {
102787       {
102788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102789       };
102790     } catch (...) {
102791       {
102792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102793       };
102794     }
102795   }
102796 }
102797
102798 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
102799     return (Dali::Toolkit::Control *)jarg1;
102800 }
102801
102802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
102803   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
102804   SignalConverter::WebViewPageLoadSignal* result = NULL;
102805   {
102806     try {
102807       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
102808     } catch (std::out_of_range& e) {
102809       {
102810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102811       };
102812     } catch (std::exception& e) {
102813       {
102814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102815       };
102816     } catch (Dali::DaliException e) {
102817       {
102818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102819       };
102820     } catch (...) {
102821       {
102822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102823       };
102824     }
102825   }
102826   return (void*) result;
102827 }
102828
102829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
102830   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
102831   SignalConverter::WebViewPageLoadSignal* result = NULL;
102832   {
102833     try {
102834       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
102835     } catch (std::out_of_range& e) {
102836       {
102837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102838       };
102839     } catch (std::exception& e) {
102840       {
102841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102842       };
102843     } catch (Dali::DaliException e) {
102844       {
102845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102846       };
102847     } catch (...) {
102848       {
102849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102850       };
102851     }
102852   }
102853   return (void*) result;
102854 }
102855
102856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
102857 {
102858   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
102859   {
102860     try {
102861       delete object;
102862     } catch (std::out_of_range& e) {
102863       {
102864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102865       };
102866     } catch (std::exception& e) {
102867       {
102868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102869       };
102870     } catch (Dali::DaliException e) {
102871       {
102872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102873       };
102874     } catch (...) {
102875       {
102876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102877       };
102878     }
102879   }
102880 }
102881
102882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
102883 {
102884   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
102885   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
102886   {
102887     try {
102888       proxy->Connect(callback);
102889     } catch (std::out_of_range& e) {
102890       {
102891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102892       };
102893     } catch (std::exception& e) {
102894       {
102895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102896       };
102897     } catch (Dali::DaliException e) {
102898       {
102899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102900       };
102901     } catch (...) {
102902       {
102903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102904       };
102905     }
102906   }
102907 }
102908
102909
102910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
102911   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
102912   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
102913   {
102914     try {
102915       proxy->Disconnect(callback);
102916     } catch (std::out_of_range& e) {
102917       {
102918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102919       };
102920     } catch (std::exception& e) {
102921       {
102922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102923       };
102924     } catch (Dali::DaliException e) {
102925       {
102926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102927       };
102928     } catch (...) {
102929       {
102930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102931       };
102932     }
102933   }
102934 }
102935
102936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
102937   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
102938   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
102939   {
102940     try {
102941       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
102942     } catch (std::out_of_range& e) {
102943       {
102944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102945       };
102946     } catch (std::exception& e) {
102947       {
102948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102949       };
102950     } catch (Dali::DaliException e) {
102951       {
102952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102953       };
102954     } catch (...) {
102955       {
102956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102957       };
102958     }
102959   }
102960   return (void*) result;
102961 }
102962
102963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
102964 {
102965   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
102966   {
102967     try {
102968       delete object;
102969     } catch (std::out_of_range& e) {
102970       {
102971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102972       };
102973     } catch (std::exception& e) {
102974       {
102975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102976       };
102977     } catch (Dali::DaliException e) {
102978       {
102979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102980       };
102981     } catch (...) {
102982       {
102983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102984       };
102985     }
102986   }
102987 }
102988
102989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
102990 {
102991   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
102992   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
102993   {
102994     try {
102995       proxy->Connect(callback);
102996     } catch (std::out_of_range& e) {
102997       {
102998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102999       };
103000     } catch (std::exception& e) {
103001       {
103002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103003       };
103004     } catch (Dali::DaliException e) {
103005       {
103006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103007       };
103008     } catch (...) {
103009       {
103010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103011       };
103012     }
103013   }
103014 }
103015
103016
103017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
103018   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
103019   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
103020   {
103021     try {
103022       proxy->Disconnect(callback);
103023     } catch (std::out_of_range& e) {
103024       {
103025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103026       };
103027     } catch (std::exception& e) {
103028       {
103029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103030       };
103031     } catch (Dali::DaliException e) {
103032       {
103033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103034       };
103035     } catch (...) {
103036       {
103037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103038       };
103039     }
103040   }
103041 }
103042
103043 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
103044   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
103045   char * jresult = SWIG_csharp_string_callback((const char *)result);
103046   return jresult;
103047 }
103048
103049 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
103050   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
103051   return result;
103052 }
103053
103054 #ifdef __cplusplus
103055 }
103056 #endif
103057